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

add io diagnose info

Browse Source
This commit is contained in:
renju96 2023-07-24 12:42:41 +00:00 committed by ob-robot
parent 96331c927c
commit cfaace79c2
36 changed files with 464 additions and 105 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
deps/oblib/src/lib/ob_define.h vendored
View File

@ -169,7 +169,19 @@ const int64_t OB_MAX_SPAN_LENGTH = 1024;
const int64_t OB_MAX_SPAN_TAG_LENGTH = 8 * 1024L;
const int64_t OB_MAX_REF_TYPE_LENGTH = 10;
const int64_t OB_MAX_LS_FLAG_LENGTH = 2048;
const int64_t RESOURCE_GROUP_START_ID = 10000;
const int64_t USER_RESOURCE_GROUP_START_ID = 10000;
const int64_t USER_RESOURCE_GROUP_END_ID = 19999;
const int64_t SYS_RESOURCE_GROUP_START_ID = 20000;
const int64_t SYS_RESOURCE_GROUP_CNT = 21; //accord ObIOModule
OB_INLINE bool is_user_group(const int64_t group_id)
{
return group_id >= USER_RESOURCE_GROUP_START_ID && group_id <= USER_RESOURCE_GROUP_END_ID;
}
OB_INLINE bool is_sys_group(const int64_t group_id)
{
return group_id >= SYS_RESOURCE_GROUP_START_ID && group_id <= SYS_RESOURCE_GROUP_START_ID + SYS_RESOURCE_GROUP_CNT;
}
// See ObDeviceHealthStatus for more information
const int64_t OB_MAX_DEVICE_HEALTH_STATUS_STR_LENGTH = 20;

2
src/observer/ob_inner_sql_rpc_processor.cpp
View File

@ -481,7 +481,7 @@ int ObInnerSqlRpcP::set_session_param_to_conn(
ResourceGroupGuard::ResourceGroupGuard(const int32_t group_id)
: group_change_(false), old_group_id_(0)
{
if (group_id >= RESOURCE_GROUP_START_ID) {
if (is_user_group(group_id)) {
old_group_id_ = THIS_WORKER.get_group_id();
THIS_WORKER.set_group_id(group_id);
group_change_ = true;

187
src/observer/virtual_table/ob_all_virtual_io_status.cpp
View File

@ -333,84 +333,127 @@ int ObAllVirtualIOQuota::init(const common::ObAddr &addr)
ret = OB_TENANT_NOT_EXIST;
LOG_WARN("tenant not exist", K(ret), K(cur_tenant_id));
}
} else {
ObIOUsage &io_usage = tenant_holder.get_ptr()->get_io_usage();
const ObTenantIOConfig &io_config = tenant_holder.get_ptr()->get_io_config();
ObIOUsage::AvgItems avg_iops, avg_size, avg_rt;
io_usage.calculate_io_usage();
io_usage.get_io_usage(avg_iops, avg_size, avg_rt);
for (int64_t i = 0; i < io_config.group_num_; ++i) {
if (io_config.group_configs_.at(i).deleted_) {
continue;
}
for (int64_t j = 0; OB_SUCC(ret) && j < static_cast<int>(ObIOMode::MAX_MODE); ++j) {
if (avg_size.at(i+1).at(j) > std::numeric_limits<double>::epsilon()) {
QuotaInfo item;
item.tenant_id_ = cur_tenant_id;
item.mode_ = static_cast<ObIOMode>(j);
item.group_id_ = io_config.group_ids_.at(i);
item.size_ = avg_size.at(i+1).at(j);
item.real_iops_ = avg_iops.at(i+1).at(j);
int64_t group_min_iops = 0, group_max_iops = 0, group_iops_weight = 0;
double iops_scale = 0;
bool is_io_ability_valid = true;
if (OB_FAIL(io_config.get_group_config(i,
group_min_iops,
group_max_iops,
group_iops_weight))) {
LOG_WARN("get group config failed", K(ret), K(i));
} else if (OB_FAIL(ObIOCalibration::get_instance().get_iops_scale(static_cast<ObIOMode>(j),
avg_size.at(i+1).at(j),
iops_scale,
is_io_ability_valid))) {
LOG_WARN("get iops scale failed", K(ret), "mode", get_io_mode_string(static_cast<ObIOMode>(j)));
} else {
item.min_iops_ = group_min_iops * iops_scale;
item.max_iops_ = group_max_iops * iops_scale;
if (OB_FAIL(quota_infos_.push_back(item))) {
LOG_WARN("push back io group item failed", K(j), K(ret), K(item));
}
}
}
}
}
if (OB_SUCC(ret)) {
// OTHER_GROUPS
for (int64_t k = 0; OB_SUCC(ret) && k < static_cast<int>(ObIOMode::MAX_MODE); ++k) {
if (avg_size.at(0).at(k) > std::numeric_limits<double>::epsilon()) {
QuotaInfo item;
item.tenant_id_ = cur_tenant_id;
item.mode_ = static_cast<ObIOMode>(k);
item.group_id_ = 0;
item.size_ = avg_size.at(0).at(k);
item.real_iops_ = avg_iops.at(0).at(k);
int64_t group_min_iops = 0, group_max_iops = 0, group_iops_weight = 0;
double iops_scale = 0;
bool is_io_ability_valid = true;
if (OB_FAIL(io_config.get_group_config(INT64_MAX,
group_min_iops,
group_max_iops,
group_iops_weight))) {
LOG_WARN("get other group config failed", K(ret), "gruop_info", io_config.other_group_config_);
} else if (OB_FAIL(ObIOCalibration::get_instance().get_iops_scale(static_cast<ObIOMode>(k),
avg_size.at(0).at(k),
iops_scale,
is_io_ability_valid))) {
LOG_WARN("get iops scale failed", K(ret), "mode", get_io_mode_string(static_cast<ObIOMode>(k)));
} else {
item.min_iops_ = group_min_iops * iops_scale;
item.max_iops_ = group_max_iops * iops_scale;
if (OB_FAIL(quota_infos_.push_back(item))) {
LOG_WARN("push back other group item failed", K(k), K(ret), K(item));
}
}
} else if (OB_FAIL(record_user_group(cur_tenant_id, tenant_holder.get_ptr()->get_io_usage(), tenant_holder.get_ptr()->get_io_config()))) {
LOG_WARN("fail to record user group item", K(ret), K(cur_tenant_id), K(tenant_holder.get_ptr()->get_io_config()));
} else if (OB_FAIL(record_sys_group(cur_tenant_id, tenant_holder.get_ptr()->get_backup_io_usage()))) {
LOG_WARN("fail to record sys group item", K(ret), K(cur_tenant_id));
}
}
if (OB_SUCC(ret)) {
is_inited_ = true;
}
}
return ret;
}
int ObAllVirtualIOQuota::record_user_group(const uint64_t tenant_id, ObIOUsage &io_usage, const ObTenantIOConfig &io_config)
{
int ret = OB_SUCCESS;
if (OB_UNLIKELY(!is_valid_tenant_id(tenant_id))) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid tenant id", K(ret), K(tenant_id));
} else {
ObIOUsage::AvgItems avg_iops, avg_size, avg_rt;
io_usage.calculate_io_usage();
io_usage.get_io_usage(avg_iops, avg_size, avg_rt);
for (int64_t i = 0; i < io_config.group_num_; ++i) {
if (io_config.group_configs_.at(i).deleted_) {
continue;
}
for (int64_t j = 0; OB_SUCC(ret) && j < static_cast<int>(ObIOMode::MAX_MODE); ++j) {
if (avg_size.at(i+1).at(j) > std::numeric_limits<double>::epsilon()) {
QuotaInfo item;
item.tenant_id_ = tenant_id;
item.mode_ = static_cast<ObIOMode>(j);
item.group_id_ = io_config.group_ids_.at(i);
item.size_ = avg_size.at(i+1).at(j);
item.real_iops_ = avg_iops.at(i+1).at(j);
int64_t group_min_iops = 0, group_max_iops = 0, group_iops_weight = 0;
double iops_scale = 0;
bool is_io_ability_valid = true;
if (OB_FAIL(io_config.get_group_config(i,
group_min_iops,
group_max_iops,
group_iops_weight))) {
LOG_WARN("get group config failed", K(ret), K(i));
} else if (OB_FAIL(ObIOCalibration::get_instance().get_iops_scale(static_cast<ObIOMode>(j),
avg_size.at(i+1).at(j),
iops_scale,
is_io_ability_valid))) {
LOG_WARN("get iops scale failed", K(ret), "mode", get_io_mode_string(static_cast<ObIOMode>(j)));
} else {
item.min_iops_ = group_min_iops * iops_scale;
item.max_iops_ = group_max_iops * iops_scale;
if (OB_FAIL(quota_infos_.push_back(item))) {
LOG_WARN("push back io group item failed", K(j), K(ret), K(item));
}
}
}
}
}
if (OB_SUCC(ret)) {
is_inited_ = true;
// OTHER_GROUPS
for (int64_t k = 0; OB_SUCC(ret) && k < static_cast<int>(ObIOMode::MAX_MODE); ++k) {
if (avg_size.at(0).at(k) > std::numeric_limits<double>::epsilon()) {
QuotaInfo item;
item.tenant_id_ = tenant_id;
item.mode_ = static_cast<ObIOMode>(k);
item.group_id_ = 0;
item.size_ = avg_size.at(0).at(k);
item.real_iops_ = avg_iops.at(0).at(k);
int64_t group_min_iops = 0, group_max_iops = 0, group_iops_weight = 0;
double iops_scale = 0;
bool is_io_ability_valid = true;
if (OB_FAIL(io_config.get_group_config(INT64_MAX,
group_min_iops,
group_max_iops,
group_iops_weight))) {
LOG_WARN("get other group config failed", K(ret), "gruop_info", io_config.other_group_config_);
} else if (OB_FAIL(ObIOCalibration::get_instance().get_iops_scale(static_cast<ObIOMode>(k),
avg_size.at(0).at(k),
iops_scale,
is_io_ability_valid))) {
LOG_WARN("get iops scale failed", K(ret), "mode", get_io_mode_string(static_cast<ObIOMode>(k)));
} else {
item.min_iops_ = group_min_iops * iops_scale;
item.max_iops_ = group_max_iops * iops_scale;
if (OB_FAIL(quota_infos_.push_back(item))) {
LOG_WARN("push back other group item failed", K(k), K(ret), K(item));
}
}
}
}
}
}
return ret;
}
int ObAllVirtualIOQuota::record_sys_group(const uint64_t tenant_id, ObSysIOUsage &sys_io_usage)
{
int ret = OB_SUCCESS;
if (OB_UNLIKELY(!is_valid_tenant_id(tenant_id))) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid tenant id", K(ret), K(tenant_id));
} else {
ObSysIOUsage::SysAvgItems sys_avg_iops, sys_avg_size, sys_avg_rt;
sys_io_usage.calculate_io_usage();
sys_io_usage.get_io_usage(sys_avg_iops, sys_avg_size, sys_avg_rt);
for (int64_t i = 0; i < SYS_RESOURCE_GROUP_CNT; ++i) {
for (int64_t j = 0; OB_SUCC(ret) && j < static_cast<int>(ObIOMode::MAX_MODE); ++j) {
if (sys_avg_size.at(i).at(j) > std::numeric_limits<double>::epsilon()) {
QuotaInfo item;
item.tenant_id_ = tenant_id;
item.mode_ = static_cast<ObIOMode>(j);
item.group_id_ = SYS_RESOURCE_GROUP_START_ID + j;
item.size_ = sys_avg_size.at(i).at(j);
item.real_iops_ = sys_avg_iops.at(i).at(j);
item.min_iops_ = INT64_MAX;
item.max_iops_ = INT64_MAX;
if (OB_FAIL(quota_infos_.push_back(item))) {
LOG_WARN("push back io group item failed", K(j), K(ret), K(item));
}
}
}
}
}
return ret;

2
src/observer/virtual_table/ob_all_virtual_io_status.h
View File

@ -97,6 +97,8 @@ public:
ObAllVirtualIOQuota();
virtual ~ObAllVirtualIOQuota();
int init(const common::ObAddr &addr);
int record_user_group(const uint64_t tenant_id, ObIOUsage &io_usage, const ObTenantIOConfig &io_config);
int record_sys_group(const uint64_t tenant_id, ObSysIOUsage &sys_io_usage);
virtual void reset() override;
virtual int inner_get_next_row(common::ObNewRow *&row) override;
private:

2
src/share/io/ob_io_calibration.cpp
View File

@ -388,7 +388,7 @@ void ObIOBenchRunner::run1()
io_info.size_ = load_.size_;
io_info.buf_ = ObIOMode::READ == load_.mode_ ? nullptr : write_buf_;
io_info.flag_.set_mode(load_.mode_);
io_info.flag_.set_group_id(0);
io_info.flag_.set_group_id(ObIOModule::CALIBRATION_IO);
io_info.flag_.set_wait_event(ObIOMode::READ == load_.mode_ ?
ObWaitEventIds::DB_FILE_DATA_READ : ObWaitEventIds::DB_FILE_COMPACT_WRITE);
io_info.flag_.set_unlimited(true);

92
src/share/io/ob_io_define.cpp
View File

@ -57,6 +57,76 @@ ObIOMode oceanbase::common::get_io_mode_enum(const char *mode_string)
return mode;
}
const char *oceanbase::common::get_io_sys_group_name(ObIOModule module)
{
const char *ret_name = "UNKNOWN";
switch (module) {
case ObIOModule::SLOG_IO:
ret_name = "SLOG_IO";
break;
case ObIOModule::CALIBRATION_IO:
ret_name = "CALIBRATION_IO";
break;
case ObIOModule::DETECT_IO:
ret_name = "DETECT_IO";
break;
case ObIOModule::DIRECT_LOAD_IO:
ret_name = "DIRECT_LOAD_IO";
break;
case ObIOModule::SHARED_BLOCK_RW_IO:
ret_name = "SHARED_BLOCK_ReaderWriter_IO";
break;
case ObIOModule::SSTABLE_WHOLE_SCANNER_IO:
ret_name = "SSTABLE_WHOLE_SCANNER_IO";
break;
case ObIOModule::INSPECT_BAD_BLOCK_IO:
ret_name = "INSPECT_BAD_BLOCK_IO";
break;
case ObIOModule::SSTABLE_INDEX_BUILDER_IO:
ret_name = "SSTABLE_INDEX_BUILDER_IO";
break;
case ObIOModule::BACKUP_READER_IO:
ret_name = "BACKUP_READER_IO";
break;
case ObIOModule::BLOOM_FILTER_IO:
ret_name = "BLOOM_FILTER_IO";
break;
case ObIOModule::SHARED_MACRO_BLOCK_MGR_IO:
ret_name = "SHARED_MACRO_BLOCK_MGR_IO";
break;
case ObIOModule::INDEX_BLOCK_TREE_CURSOR_IO:
ret_name = "INDEX_BLOCK_TREE_CURSOR_IO";
break;
case ObIOModule::MICRO_BLOCK_CACHE_IO:
ret_name = "MICRO_BLOCK_CACHE_IO";
break;
case ObIOModule::ROOT_BLOCK_IO:
ret_name = "ROOT_BLOCK_IO";
break;
case ObIOModule::TMP_PAGE_CACHE_IO:
ret_name = "TMP_PAGE_CACHE_IO";
break;
case ObIOModule::INDEX_BLOCK_MICRO_ITER_IO:
ret_name = "INDEX_BLOCK_MICRO_ITER_IO";
break;
case ObIOModule::HA_COPY_MACRO_BLOCK_IO:
ret_name = "HA_COPY_MACRO_BLOCK_IO";
break;
case ObIOModule::LINKED_MACRO_BLOCK_IO:
ret_name = "LINKED_MACRO_BLOCK_IO";
break;
case ObIOModule::HA_MACRO_BLOCK_WRITER_IO:
ret_name = "HA_MACRO_BLOCK_WRITER_IO";
break;
case ObIOModule::TMP_TENANT_MEM_BLOCK_IO:
ret_name = "TMP_TENANT_MEM_BLOCK_IO";
break;
default:
break;
}
return ret_name;
}
/****************** IOFlag **********************/
ObIOFlag::ObIOFlag()
: flag_(0)
@ -91,6 +161,11 @@ ObIOMode ObIOFlag::get_mode() const
return static_cast<ObIOMode>(mode_);
}
void ObIOFlag::set_group_id(ObIOModule module)
{
group_id_ = THIS_WORKER.get_group_id() != 0 ? THIS_WORKER.get_group_id() : static_cast<int64_t>(module);
}
void ObIOFlag::set_group_id(int64_t group_id)
{
group_id_ = group_id;
@ -106,6 +181,11 @@ int64_t ObIOFlag::get_group_id() const
return group_id_;
}
ObIOModule ObIOFlag::get_io_module() const
{
return static_cast<ObIOModule>(group_id_);
}
int64_t ObIOFlag::get_wait_event() const
{
return wait_event_id_;
@ -435,8 +515,8 @@ int64_t ObIORequest::get_group_id() const
uint64_t ObIORequest::get_io_usage_index()
{
uint64_t index = 0;
if (get_group_id() < RESOURCE_GROUP_START_ID) {
//other group , do nothing
if (!is_user_group(get_group_id())) {
//other group or sys group , do nothing
} else {
index = tenant_io_mgr_.get_ptr()->get_usage_index(get_group_id());
}
@ -630,7 +710,11 @@ void ObIORequest::finish(const ObIORetCode &ret_code)
ret_code_ = ret_code;
is_finished_ = true;
if (OB_NOT_NULL(tenant_io_mgr_.get_ptr())) {
tenant_io_mgr_.get_ptr()->io_usage_.accumulate(*this);
if (get_group_id() > USER_RESOURCE_GROUP_END_ID) {
tenant_io_mgr_.get_ptr()->io_backup_usage_.accumulate(*this);
} else {
tenant_io_mgr_.get_ptr()->io_usage_.accumulate(*this);
}
tenant_io_mgr_.get_ptr()->io_usage_.record_request_finish(*this);
}
if (OB_UNLIKELY(OB_SUCCESS != ret_code_.io_ret_)) {
@ -1189,7 +1273,7 @@ int ObTenantIOConfig::parse_group_config(const char *config_str)
int ObTenantIOConfig::add_single_group_config(const uint64_t tenant_id, const int64_t group_id, int64_t min_percent, int64_t max_percent, int64_t weight_percent)
{
int ret = OB_SUCCESS;
if (group_id < RESOURCE_GROUP_START_ID || !is_valid_tenant_id(tenant_id) ||
if (OB_UNLIKELY(!is_user_group(group_id)) || !is_valid_tenant_id(tenant_id) ||
min_percent < 0 || min_percent > 100 ||
max_percent < 0 || max_percent > 100 ||
weight_percent < 0 || weight_percent > 100 ||

27
src/share/io/ob_io_define.h
View File

@ -43,6 +43,31 @@ enum class ObIOMode : uint8_t
const char *get_io_mode_string(const ObIOMode mode);
ObIOMode get_io_mode_enum(const char *mode_string);
enum ObIOModule {
SLOG_IO = 20000,
CALIBRATION_IO = 20001,
DETECT_IO = 20002,
DIRECT_LOAD_IO = 20003,
SHARED_BLOCK_RW_IO = 20004,
SSTABLE_WHOLE_SCANNER_IO = 20005,
INSPECT_BAD_BLOCK_IO = 20006,
SSTABLE_INDEX_BUILDER_IO = 20007,
BACKUP_READER_IO = 20008,
BLOOM_FILTER_IO = 20009,
SHARED_MACRO_BLOCK_MGR_IO = 20010,
INDEX_BLOCK_TREE_CURSOR_IO = 20011,
MICRO_BLOCK_CACHE_IO = 20012,
ROOT_BLOCK_IO = 20013,
TMP_PAGE_CACHE_IO = 20014,
INDEX_BLOCK_MICRO_ITER_IO = 20015,
HA_COPY_MACRO_BLOCK_IO = 20016,
LINKED_MACRO_BLOCK_IO = 20017,
HA_MACRO_BLOCK_WRITER_IO = 20018,
TMP_TENANT_MEM_BLOCK_IO = 20019,
MAX_IO = 20020
};
const char *get_io_sys_group_name(ObIOModule module);
struct ObIOFlag final
{
public:
@ -52,9 +77,11 @@ public:
bool is_valid() const;
void set_mode(ObIOMode mode);
ObIOMode get_mode() const;
void set_group_id(ObIOModule module);
void set_group_id(int64_t group_id);
void set_wait_event(int64_t wait_event_id);
int64_t get_group_id() const;
ObIOModule get_io_module() const;
int64_t get_wait_event() const;
void set_read();
bool is_read() const;

49
src/share/io/ob_io_manager.cpp
View File

@ -686,7 +686,9 @@ int ObTenantIOManager::init(const uint64_t tenant_id,
} else if (OB_FAIL(alloc_io_clock(io_allocator_, io_clock_))) {
LOG_WARN("alloc io clock failed", K(ret));
} else if (OB_FAIL(io_usage_.init(io_config.group_num_))) {
LOG_WARN("init io usage failed", K(ret), K(io_usage_));
LOG_WARN("init io usage failed", K(ret), K(io_usage_), K(io_config.group_num_));
} else if (OB_FAIL(io_backup_usage_.init())) {
LOG_WARN("init io usage failed", K(ret), K(io_backup_usage_), K(SYS_RESOURCE_GROUP_CNT));
} else if (OB_FAIL(io_clock_->init(io_config, &io_usage_))) {
LOG_WARN("init io clock failed", K(ret), K(io_config));
} else if (OB_FAIL(io_scheduler->init_group_queues(tenant_id, io_config.group_num_, &io_allocator_))) {
@ -941,8 +943,11 @@ int ObTenantIOManager::init_group_index_map(const int64_t tenant_id,
int ObTenantIOManager::get_group_index(const int64_t group_id, uint64_t &index)
{
int ret = group_id_index_map_.get_refactored(group_id, index);
if (OB_FAIL(ret)) {
int ret = OB_SUCCESS;
if (OB_UNLIKELY(!is_user_group(group_id))) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid group id", K(ret), K(group_id));
} else if (OB_FAIL(group_id_index_map_.get_refactored(group_id, index))) {
if(OB_HASH_NOT_EXIST != ret) {
LOG_WARN("get index from map failed", K(ret), K(group_id), K(index));
}
@ -1007,7 +1012,7 @@ int ObTenantIOManager::modify_io_config(const uint64_t group_id,
} else {
uint64_t index = INT64_MAX;
DRWLock::WRLockGuard guard(io_config_lock_);
if (group_id < RESOURCE_GROUP_START_ID && group_id > 0) {
if (OB_UNLIKELY(!is_user_group(group_id))) {
ret = OB_INVALID_CONFIG;
LOG_WARN("invalid group id", K(ret), K(tenant_id_), K(group_id));
} else if (min_percent < 0 || min_percent > 100 ||
@ -1073,9 +1078,9 @@ int ObTenantIOManager::add_group_io_config(const int64_t group_id,
} else if (OB_UNLIKELY(!is_working())) {
ret = OB_STATE_NOT_MATCH;
LOG_WARN("tenant not working", K(ret), K(tenant_id_));
} else if (group_id < RESOURCE_GROUP_START_ID || min_percent < 0 || min_percent > 100 ||
max_percent < 0 || max_percent > 100 || max_percent < min_percent ||
weight_percent < 0 || weight_percent > 100) {
} else if (OB_UNLIKELY(!is_user_group(group_id)) || min_percent < 0 || min_percent > 100 ||
max_percent < 0 || max_percent > 100 || max_percent < min_percent ||
weight_percent < 0 || weight_percent > 100) {
ret = OB_INVALID_CONFIG;
LOG_WARN("invalid group config", K(ret), K(group_id), K(min_percent), K(max_percent), K(weight_percent));
} else {
@ -1126,7 +1131,7 @@ int ObTenantIOManager::reset_consumer_group_config(const int64_t group_id)
} else if (OB_UNLIKELY(!is_working())) {
ret = OB_STATE_NOT_MATCH;
LOG_WARN("tenant not working", K(ret), K(tenant_id_));
} else if (group_id < RESOURCE_GROUP_START_ID) {
} else if (OB_UNLIKELY(!is_user_group(group_id))) {
ret = OB_INVALID_CONFIG;
LOG_WARN("cannot reset other group io config", K(ret), K(group_id));
} else {
@ -1165,7 +1170,7 @@ int ObTenantIOManager::delete_consumer_group_config(const int64_t group_id)
} else if (OB_UNLIKELY(!is_working())) {
ret = OB_STATE_NOT_MATCH;
LOG_WARN("tenant not working", K(ret), K(tenant_id_));
} else if (group_id < RESOURCE_GROUP_START_ID) {
} else if (OB_UNLIKELY(!is_user_group(group_id))) {
ret = OB_INVALID_CONFIG;
LOG_WARN("cannot delete other group io config", K(ret), K(group_id));
} else {
@ -1283,7 +1288,10 @@ void ObTenantIOManager::print_io_status()
bool need_print_io_config = false;
ObIOUsage::AvgItems avg_iops, avg_size, avg_rt;
io_usage_.calculate_io_usage();
io_backup_usage_.calculate_io_usage();
ObSysIOUsage::SysAvgItems sys_avg_iops, sys_avg_size, sys_avg_rt;
io_usage_.get_io_usage(avg_iops, avg_size, avg_rt);
io_backup_usage_.get_io_usage(sys_avg_iops, sys_avg_size, sys_avg_rt);
for (int64_t i = 1; i < io_usage_.get_io_usage_num(); ++i) {
if (io_config_.group_configs_.at(i-1).deleted_) {
continue;
@ -1329,6 +1337,29 @@ void ObTenantIOManager::print_io_status()
need_print_io_config = true;
}
// MOCK SYS GROUPS
for (int64_t j = 0; j < SYS_RESOURCE_GROUP_CNT; ++j) {
ObIOModule module = static_cast<ObIOModule>(SYS_RESOURCE_GROUP_START_ID + j);
if (sys_avg_size.at(j).at(static_cast<int>(ObIOMode::READ)) > std::numeric_limits<double>::epsilon()) {
snprintf(io_status, sizeof(io_status), "sys_group_name: %s, mode: read, size: %10.2f, iops: %8.2f, rt: %8.2f",
get_io_sys_group_name(module),
sys_avg_size.at(j).at(static_cast<int>(ObIOMode::READ)),
sys_avg_iops.at(j).at(static_cast<int>(ObIOMode::READ)),
sys_avg_rt.at(j).at(static_cast<int>(ObIOMode::READ)));
LOG_INFO("[IO STATUS SYS]", K_(tenant_id), KCSTRING(io_status));
need_print_io_config = true;
}
if (sys_avg_size.at(j).at(static_cast<int>(ObIOMode::WRITE)) > std::numeric_limits<double>::epsilon()) {
snprintf(io_status, sizeof(io_status), "sys_group_name: %s, mode: write, size: %10.2f, iops: %8.2f, rt: %8.2f",
get_io_sys_group_name(module),
sys_avg_size.at(j).at(static_cast<int>(ObIOMode::WRITE)),
sys_avg_iops.at(j).at(static_cast<int>(ObIOMode::WRITE)),
sys_avg_rt.at(j).at(static_cast<int>(ObIOMode::WRITE)));
LOG_INFO("[IO STATUS SYS]", K_(tenant_id), KCSTRING(io_status));
need_print_io_config = true;
}
}
if (need_print_io_config) {
ObArray<int64_t> queue_count_array;
int ret = OB_SUCCESS;

2
src/share/io/ob_io_manager.h
View File

@ -117,6 +117,7 @@ public:
int enqueue_callback(ObIORequest &req);
ObTenantIOClock *get_io_clock() { return io_clock_; }
ObIOUsage &get_io_usage() { return io_usage_; }
ObSysIOUsage &get_backup_io_usage() { return io_backup_usage_; }
int update_basic_io_config(const ObTenantIOConfig &io_config);
int alloc_io_request(ObIAllocator &allocator,const int64_t callback_size, ObIORequest *&req);
int alloc_io_clock(ObIAllocator &allocator, ObTenantIOClock *&io_clock);
@ -170,6 +171,7 @@ private:
ObIOScheduler *io_scheduler_;
ObIOCallbackManager callback_mgr_;
ObIOUsage io_usage_;
ObSysIOUsage io_backup_usage_; //for backup mock group
ObIOTracer io_tracer_;
DRWLock io_config_lock_; //for map and config
hash::ObHashMap<uint64_t, uint64_t> group_id_index_map_; //key:group_id, value:index

112
src/share/io/ob_io_struct.cpp
View File

@ -525,6 +525,7 @@ int ObIOUsage::refresh_group_num(const int64_t group_num)
}
return ret;
}
void ObIOUsage::accumulate(ObIORequest &req)
{
if (req.time_log_.return_ts_ > 0) {
@ -595,6 +596,113 @@ int64_t ObIOUsage::to_string(char* buf, const int64_t buf_len) const
return pos;
}
/****************** ObSysIOUsage **********************/
ObSysIOUsage::ObSysIOUsage()
: io_stats_(),
io_estimators_(),
group_avg_iops_(),
group_avg_byte_(),
group_avg_rt_us_()
{
}
ObSysIOUsage::~ObSysIOUsage()
{
}
int ObSysIOUsage::init()
{
int ret = OB_SUCCESS;
if (OB_FAIL(io_stats_.reserve(SYS_RESOURCE_GROUP_CNT)) ||
OB_FAIL(io_estimators_.reserve(SYS_RESOURCE_GROUP_CNT)) ||
OB_FAIL(group_avg_iops_.reserve(SYS_RESOURCE_GROUP_CNT)) ||
OB_FAIL(group_avg_byte_.reserve(SYS_RESOURCE_GROUP_CNT)) ||
OB_FAIL(group_avg_rt_us_.reserve(SYS_RESOURCE_GROUP_CNT))) {
LOG_WARN("reserver group failed", K(ret), K(SYS_RESOURCE_GROUP_CNT));
} else {
for (int64_t i = 0; OB_SUCC(ret) && i < SYS_RESOURCE_GROUP_CNT; ++i) {
ObSEArray<ObIOStat, SYS_RESOURCE_GROUP_CNT> cur_stat_array;
ObSEArray<ObIOStatDiff, SYS_RESOURCE_GROUP_CNT> cur_estimators_array;
ObSEArray<double, SYS_RESOURCE_GROUP_CNT> cur_avg_iops;
ObSEArray<double, SYS_RESOURCE_GROUP_CNT> cur_avg_byte;
ObSEArray<double, SYS_RESOURCE_GROUP_CNT> cur_avg_rt_us;
if (OB_FAIL(cur_stat_array.reserve(static_cast<int>(ObIOMode::MAX_MODE))) ||
OB_FAIL(cur_estimators_array.reserve(static_cast<int>(ObIOMode::MAX_MODE))) ||
OB_FAIL(cur_avg_iops.reserve(static_cast<int>(ObIOMode::MAX_MODE))) ||
OB_FAIL(cur_avg_byte.reserve(static_cast<int>(ObIOMode::MAX_MODE))) ||
OB_FAIL(cur_avg_rt_us.reserve(static_cast<int>(ObIOMode::MAX_MODE)))) {
LOG_WARN("reserver group failed", K(ret), K(SYS_RESOURCE_GROUP_CNT));
} else {
for (int64_t j = 0; OB_SUCC(ret) && j < static_cast<int>(ObIOMode::MAX_MODE); ++j) {
ObIOStat cur_stat;
ObIOStatDiff cur_diff;
if (OB_FAIL(cur_stat_array.push_back(cur_stat))) {
LOG_WARN("push stat failed", K(ret), K(i), K(j));
} else if (OB_FAIL(cur_estimators_array.push_back(cur_diff))) {
LOG_WARN("push estimator failed", K(ret), K(i), K(j));
} else if (OB_FAIL(cur_avg_iops.push_back(0))) {
LOG_WARN("push avg_iops failed", K(ret), K(i), K(j));
} else if (OB_FAIL(cur_avg_byte.push_back(0))) {
LOG_WARN("push avg_byte failed", K(ret), K(i), K(j));
} else if (OB_FAIL(cur_avg_rt_us.push_back(0))) {
LOG_WARN("push avg_rt failed", K(ret), K(i), K(j));
}
}
}
if (OB_SUCC(ret)) {
if (OB_FAIL(io_stats_.push_back(cur_stat_array))) {
LOG_WARN("push stat array failed", K(ret), K(i));
} else if (OB_FAIL(io_estimators_.push_back(cur_estimators_array))) {
LOG_WARN("push estimator array failed", K(ret), K(i));
} else if (OB_FAIL(group_avg_iops_.push_back(cur_avg_iops))) {
LOG_WARN("push avg_iops array failed", K(ret), K(i));
} else if (OB_FAIL(group_avg_byte_.push_back(cur_avg_byte))) {
LOG_WARN("push avg_byte array failed", K(ret), K(i));
} else if (OB_FAIL(group_avg_rt_us_.push_back(cur_avg_rt_us))) {
LOG_WARN("push avg_rt array failed", K(ret), K(i));
}
}
}
}
return ret;
}
void ObSysIOUsage::accumulate(ObIORequest &req)
{
if (OB_UNLIKELY(!is_sys_group(req.get_group_id()))) {
// ignore
} else if (req.time_log_.return_ts_ > 0) {
const int64_t idx = req.get_group_id() - SYS_RESOURCE_GROUP_START_ID;
const int64_t device_delay = get_io_interval(req.time_log_.return_ts_, req.time_log_.submit_ts_);
io_stats_.at(idx).at(static_cast<int>(req.get_mode()))
.accumulate(1, req.io_size_, device_delay);
}
}
void ObSysIOUsage::calculate_io_usage()
{
for (int64_t i = 0; i < SYS_RESOURCE_GROUP_CNT; ++i) {
for (int64_t j = 0; j < static_cast<int>(ObIOMode::MAX_MODE); ++j) {
ObIOStatDiff &cur_io_estimator = io_estimators_.at(i).at(j);
ObIOStat &cur_io_stat = io_stats_.at(i).at(j);
cur_io_estimator.diff(cur_io_stat,
group_avg_iops_.at(i).at(j),
group_avg_byte_.at(i).at(j),
group_avg_rt_us_.at(i).at(j));
}
}
}
void ObSysIOUsage::get_io_usage(SysAvgItems &avg_iops, SysAvgItems &avg_bytes, SysAvgItems &avg_rt_us)
{
avg_iops.assign(group_avg_iops_);
avg_bytes.assign(group_avg_byte_);
avg_rt_us.assign(group_avg_rt_us_);
}
/****************** CpuUsage **********************/
ObCpuUsage::ObCpuUsage()
: last_usage_(),
@ -1002,7 +1110,7 @@ int ObIOSender::enqueue_request(ObIORequest &req)
} else {
uint64_t index = INT_MAX64;
const int64_t group_id = tmp_req->get_group_id();
if (group_id < RESOURCE_GROUP_START_ID) { //other
if (!is_user_group(group_id)) { //other
tmp_phy_queue = &(io_group_queues->other_phy_queue_);
} else if (OB_FAIL(req.tenant_io_mgr_.get_ptr()->get_group_index(group_id, index))) {
// 防止删除group、新建group等情况发生时在途req无法找到对应的group
@ -2948,7 +3056,7 @@ int ObIOFaultDetector::record_read_failure(const ObIORequest &req)
LOG_WARN("alloc RetryTask failed", K(ret));
} else {
retry_task->io_info_ = req.io_info_;
retry_task->io_info_.flag_.set_group_id(0);
retry_task->io_info_.flag_.set_group_id(ObIOModule::DETECT_IO);
retry_task->io_info_.callback_ = nullptr;
retry_task->timeout_ms_ = 5000L; // 5s
if (OB_FAIL(TG_PUSH_TASK(TGDefIDs::IO_HEALTH, retry_task))) {

21
src/share/io/ob_io_struct.h
View File

@ -163,6 +163,27 @@ private:
ObSEArray<int64_t, GROUP_START_NUM> doing_request_count_;
};
class ObSysIOUsage final
{
public:
ObSysIOUsage();
~ObSysIOUsage();
int init();
void accumulate(ObIORequest &req);
void calculate_io_usage();
typedef ObSEArray<ObSEArray<double, SYS_RESOURCE_GROUP_CNT>, 2> SysAvgItems;
void get_io_usage(SysAvgItems &avg_iops, SysAvgItems &avg_bytes, SysAvgItems &avg_rt_us);
void record_request_start(ObIORequest &req);
void record_request_finish(ObIORequest &req);
TO_STRING_KV(K(io_stats_), K(io_estimators_), K(group_avg_iops_), K(group_avg_byte_), K(group_avg_rt_us_));
private:
ObSEArray<ObSEArray<ObIOStat, SYS_RESOURCE_GROUP_CNT>, 2> io_stats_;
ObSEArray<ObSEArray<ObIOStatDiff, SYS_RESOURCE_GROUP_CNT>, 2> io_estimators_;
SysAvgItems group_avg_iops_;
SysAvgItems group_avg_byte_;
SysAvgItems group_avg_rt_us_;
};
class ObCpuUsage final
{
public:

4
src/share/redolog/ob_log_file_handler.cpp
View File

@ -253,7 +253,7 @@ int ObLogFileHandler::inner_read(const ObIOFd &io_fd, void *buf, const int64_t s
io_info.offset_ = offset + read_sz;
io_info.size_ = size - read_sz;
io_info.flag_.set_mode(ObIOMode::READ);
io_info.flag_.set_group_id(THIS_WORKER.get_group_id());
io_info.flag_.set_group_id(ObIOModule::SLOG_IO);
io_info.flag_.set_wait_event(ObWaitEventIds::DB_FILE_COMPACT_READ);
io_info.buf_ = nullptr;
io_info.callback_ = nullptr;
@ -341,7 +341,7 @@ int ObLogFileHandler::normal_retry_write(void *buf, int64_t size, int64_t offset
io_info.fd_ = io_fd_;
io_info.offset_ = offset;
io_info.size_ = size;
io_info.flag_.set_group_id(THIS_WORKER.get_group_id());
io_info.flag_.set_group_id(ObIOModule::SLOG_IO);
io_info.flag_.set_wait_event(ObWaitEventIds::DB_FILE_COMPACT_WRITE);
io_info.buf_ = reinterpret_cast<const char *>(buf);
io_info.callback_ = nullptr;

4
src/share/resource_manager/ob_cgroup_ctrl.cpp
View File

@ -755,7 +755,7 @@ int ObCgroupCtrl::reset_group_iops(const uint64_t tenant_id,
} else {
LOG_WARN("fail get group id", K(ret), K(group_id), K(group_name));
}
} else if (group_id < RESOURCE_GROUP_START_ID) {
} else if (OB_UNLIKELY(!is_user_group(group_id))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid group id", K(ret), K(group_id), K(group_name));
} else if (OB_FAIL(OB_IO_MANAGER.get_tenant_io_manager(tenant_id, tenant_holder))) {
@ -790,7 +790,7 @@ int ObCgroupCtrl::delete_group_iops(const uint64_t tenant_id,
} else {
LOG_WARN("fail get group id", K(ret), K(group_id), K(group_name));
}
} else if (group_id < RESOURCE_GROUP_START_ID) {
} else if (OB_UNLIKELY(!is_user_group(group_id))) {
//OTHER_GROUPS and all cannot be deleted
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid group id", K(ret), K(group_id), K(group_name));

2
src/share/resource_manager/ob_resource_manager_proxy.cpp
View File

@ -820,7 +820,7 @@ int ObResourceManagerProxy::check_iops_validity(
uint64_t total_min = 0;
for (int64_t i = 0; OB_SUCC(ret) && i < directives.count(); ++i) {
ObPlanDirective &cur_directive = directives.at(i);
if (cur_directive.group_id_ < RESOURCE_GROUP_START_ID) {
if (OB_UNLIKELY(!is_user_group(cur_directive.group_id_))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected group id", K(cur_directive));
} else if (OB_UNLIKELY(!cur_directive.is_valid())) {

2
src/share/resource_manager/ob_resource_plan_manager.cpp
View File

@ -222,7 +222,7 @@ int ObResourcePlanManager::normalize_iops_directives(const uint64_t tenant_id,
} else {
for (int64_t i = 0; OB_SUCC(ret) && i < directives.count(); ++i) {
ObPlanDirective &cur_directive = directives.at(i);
if (cur_directive.group_id_ < RESOURCE_GROUP_START_ID) {
if (OB_UNLIKELY(!is_user_group(cur_directive.group_id_))) {
ret = OB_ERR_UNEXPECTED;
// 理论上不应该出现
LOG_WARN("unexpected error!!!", K(cur_directive));

2
src/storage/access/ob_sstable_row_whole_scanner.cpp
View File

@ -253,6 +253,7 @@ int ObSSTableRowWholeScanner::open(
read_info.size_ = sstable_->get_macro_read_size();
read_info.io_desc_.set_wait_event(ObWaitEventIds::DB_FILE_COMPACT_READ);
read_info.io_callback_ = access_ctx_->io_callback_;
read_info.io_desc_.set_group_id(ObIOModule::SSTABLE_WHOLE_SCANNER_IO);
if (OB_FAIL(ObBlockManager::async_read_block(read_info, scan_handle.macro_io_handle_))) {
LOG_WARN("Fail to read macro block", K(ret), K(read_info));
} else {
@ -362,6 +363,7 @@ int ObSSTableRowWholeScanner::prefetch()
read_info.offset_ = sstable_->get_macro_offset();
read_info.size_ = sstable_->get_macro_read_size();
read_info.io_desc_.set_wait_event(common::ObWaitEventIds::DB_FILE_COMPACT_READ);
read_info.io_desc_.set_group_id(ObIOModule::SSTABLE_WHOLE_SCANNER_IO);
read_info.io_callback_ = access_ctx_->io_callback_;
if (OB_FAIL(ObBlockManager::async_read_block(read_info, scan_handle.macro_io_handle_))) {
LOG_WARN("Fail to read macro block, ", K(ret), K(read_info));

1
src/storage/backup/ob_backup_reader.cpp
View File

@ -286,6 +286,7 @@ int ObMacroBlockBackupReader::get_macro_read_info_(
read_info.offset_ = block_info_.nested_offset_;
read_info.size_ = block_info_.nested_size_;
read_info.io_desc_.set_wait_event(ObWaitEventIds::DB_FILE_MIGRATE_READ);
read_info.io_desc_.set_group_id(ObIOModule::BACKUP_READER_IO);
}
return ret;
}

1
src/storage/blocksstable/ob_block_manager.cpp
View File

@ -1509,6 +1509,7 @@ int ObBlockManager::InspectBadBlockTask::check_block(const MacroBlockId &macro_i
read_info.offset_ = 0;
read_info.size_ = blk_mgr_.get_macro_block_size();
read_info.io_desc_.set_wait_event(ObWaitEventIds::DB_FILE_COMPACT_READ);
read_info.io_desc_.set_group_id(ObIOModule::INSPECT_BAD_BLOCK_IO);
if (OB_FAIL(ObBlockManager::async_read_block(read_info, macro_handle))) {
LOG_WARN("async read block failed", K(ret), K(macro_id), K(read_info));

1
src/storage/blocksstable/ob_bloom_filter_data_reader.cpp
View File

@ -76,6 +76,7 @@ int ObBloomFilterMacroBlockReader::read_macro_block(const MacroBlockId &macro_id
ObMacroBlockReadInfo macro_read_info;
macro_read_info.macro_block_id_ = macro_id;
macro_read_info.io_desc_.set_wait_event(is_sys_read_ ? ObWaitEventIds::DB_FILE_COMPACT_READ : ObWaitEventIds::DB_FILE_DATA_READ);
macro_read_info.io_desc_.set_group_id(ObIOModule::BLOOM_FILTER_IO);
macro_read_info.offset_ = 0;
macro_read_info.size_ = OB_SERVER_BLOCK_MGR.get_macro_block_size();
macro_handle_.reset();

1
src/storage/blocksstable/ob_bloom_filter_data_writer.cpp
View File

@ -348,6 +348,7 @@ int ObBloomFilterMacroBlockWriter::flush_macro_block()
macro_write_info.size_ = data_buffer_.capacity();
macro_write_info.size_ = OB_SERVER_BLOCK_MGR.get_macro_block_size();
macro_write_info.io_desc_.set_wait_event(ObWaitEventIds::DB_FILE_COMPACT_WRITE);
macro_write_info.io_desc_.set_group_id(ObIOModule::BLOOM_FILTER_IO);
if (OB_FAIL(ObBlockManager::write_block(macro_write_info, macro_handle))) {
STORAGE_LOG(WARN, "Failed to write bloomfilter macro block", K(ret));
} else if (OB_FAIL(block_write_ctx_.add_macro_block_id(macro_handle.get_macro_id()))) {

2
src/storage/blocksstable/ob_index_block_builder.cpp
View File

@ -874,6 +874,7 @@ int ObSSTableIndexBuilder::rewrite_small_sstable(ObSSTableMergeRes &res)
read_info.offset_ = 0;
read_info.size_ = upper_align(roots_[0]->last_macro_size_, DIO_READ_ALIGN_SIZE);
read_info.io_desc_.set_wait_event(ObWaitEventIds::DB_FILE_COMPACT_READ);
read_info.io_desc_.set_group_id(ObIOModule::SSTABLE_INDEX_BUILDER_IO);
const int64_t io_timeout_ms = std::max(GCONF._data_storage_io_timeout / 1000, DEFAULT_IO_WAIT_TIME_MS);
if (OB_FAIL(ObBlockManager::async_read_block(read_info, read_handle))) {
@ -957,6 +958,7 @@ int ObSSTableIndexBuilder::load_single_macro_block(
read_info.offset_ = 0;
read_info.size_ = OB_SERVER_BLOCK_MGR.get_macro_block_size();
read_info.io_desc_.set_wait_event(ObWaitEventIds::DB_FILE_COMPACT_READ);
read_info.io_desc_.set_group_id(ObIOModule::SSTABLE_INDEX_BUILDER_IO);
const int64_t io_timeout_ms = std::max(GCONF._data_storage_io_timeout / 1000, DEFAULT_IO_WAIT_TIME_MS);
if (OB_FAIL(ObBlockManager::async_read_block(read_info, read_handle))) {

1
src/storage/blocksstable/ob_index_block_tree_cursor.cpp
View File

@ -1016,6 +1016,7 @@ int ObIndexBlockTreeCursor::get_next_level_block(
read_info.offset_ = absolute_offset;
read_info.size_ = idx_row_header.get_block_size();
read_info.io_desc_.set_wait_event(ObWaitEventIds::DB_FILE_DATA_READ);
read_info.io_desc_.set_group_id(ObIOModule::INDEX_BLOCK_TREE_CURSOR_IO);
idx_row_header.fill_deserialize_meta(block_des_meta);
if (OB_FAIL(ObBlockManager::read_block(read_info, macro_handle))) {
LOG_WARN("Fail to read micro block from sync io", K(ret));

5
src/storage/blocksstable/ob_macro_block_handle.cpp
View File

@ -137,7 +137,8 @@ int ObMacroBlockHandle::async_read(const ObMacroBlockReadInfo &read_info)
io_info.callback_ = read_info.io_callback_;
io_info.fd_.first_id_ = read_info.macro_block_id_.first_id();
io_info.fd_.second_id_ = read_info.macro_block_id_.second_id();
io_info.flag_.set_group_id(THIS_WORKER.get_group_id());
// resource manager level is higher than default
io_info.flag_.set_group_id(read_info.io_desc_.get_io_module());
io_info.flag_.set_read();
if (OB_FAIL(ObIOManager::get_instance().aio_read(io_info, io_handle_))) {
@ -164,7 +165,7 @@ int ObMacroBlockHandle::async_write(const ObMacroBlockWriteInfo &write_info)
io_info.flag_ = write_info.io_desc_;
io_info.fd_.first_id_ = macro_id_.first_id();
io_info.fd_.second_id_ = macro_id_.second_id();
io_info.flag_.set_group_id(THIS_WORKER.get_group_id());
io_info.flag_.set_group_id(write_info.io_desc_.get_io_module());
io_info.flag_.set_write();
if (OB_FAIL(ObIOManager::get_instance().aio_write(io_info, io_handle_))) {

4
src/storage/blocksstable/ob_micro_block_cache.cpp
View File

@ -873,6 +873,7 @@ int ObIMicroBlockCache::prefetch(
ObMacroBlockReadInfo read_info;
read_info.macro_block_id_ = macro_id;
read_info.io_desc_.set_wait_event(ObWaitEventIds::DB_FILE_DATA_READ);
read_info.io_desc_.set_group_id(ObIOModule::MICRO_BLOCK_CACHE_IO);
read_info.io_callback_ = &callback;
read_info.offset_ = idx_row.get_block_offset();
read_info.size_ = idx_row.get_block_size();
@ -917,6 +918,7 @@ int ObIMicroBlockCache::prefetch(
ObMacroBlockReadInfo read_info;
read_info.macro_block_id_ = macro_id;
read_info.io_desc_.set_wait_event(ObWaitEventIds::DB_FILE_DATA_READ);
read_info.io_desc_.set_group_id(ObIOModule::MICRO_BLOCK_CACHE_IO);
read_info.io_callback_ = &callback;
read_info.offset_ = offset;
read_info.size_ = size;
@ -1028,6 +1030,7 @@ int ObDataMicroBlockCache::load_block(
} else {
macro_read_info.macro_block_id_ = micro_block_id.macro_id_;
macro_read_info.io_desc_.set_wait_event(ObWaitEventIds::DB_FILE_DATA_READ);
macro_read_info.io_desc_.set_group_id(ObIOModule::MICRO_BLOCK_CACHE_IO);
macro_read_info.offset_ = micro_block_id.offset_;
macro_read_info.size_ = micro_block_id.size_;
if (OB_FAIL(ObBlockManager::read_block(macro_read_info, macro_handle))) {
@ -1140,6 +1143,7 @@ int ObIndexMicroBlockCache::load_block(
} else {
macro_read_info.macro_block_id_ = micro_block_id.macro_id_;
macro_read_info.io_desc_.set_wait_event(ObWaitEventIds::DB_FILE_DATA_READ);
macro_read_info.io_desc_.set_group_id(ObIOModule::MICRO_BLOCK_CACHE_IO);
macro_read_info.offset_ = micro_block_id.offset_;
macro_read_info.size_ = micro_block_id.size_;
if (OB_FAIL(ObBlockManager::read_block(macro_read_info, macro_handle))) {

2
src/storage/blocksstable/ob_shared_macro_block_manager.cpp
View File

@ -269,6 +269,7 @@ int ObSharedMacroBlockMgr::check_write_complete(const MacroBlockId &macro_id, co
read_info.size_ = macro_size;
read_info.offset_ = offset_;
read_info.io_desc_.set_wait_event(ObWaitEventIds::DB_FILE_COMPACT_READ);
read_info.io_desc_.set_group_id(ObIOModule::SHARED_MACRO_BLOCK_MGR_IO);
const int64_t io_timeout_ms = std::max(GCONF._data_storage_io_timeout / 1000, DEFAULT_IO_WAIT_TIME_MS);
ObMacroBlockHandle read_handle;
ObSSTableMacroBlockChecker macro_block_checker;
@ -854,6 +855,7 @@ int ObSharedMacroBlockMgr::read_sstable_block(
read_info.offset_ = sstable.get_macro_offset();
read_info.size_ = upper_align(sstable.get_macro_read_size(), DIO_READ_ALIGN_SIZE);
read_info.io_desc_.set_wait_event(ObWaitEventIds::DB_FILE_COMPACT_READ);
read_info.io_desc_.set_group_id(ObIOModule::SHARED_MACRO_BLOCK_MGR_IO);
}
if (OB_FAIL(ObBlockManager::read_block(read_info, block_handle))) {

1
src/storage/blocksstable/ob_sstable_meta_info.cpp
View File

@ -252,6 +252,7 @@ int ObRootBlockInfo::read_block_data(
handle.reset();
read_info.io_desc_.set_mode(ObIOMode::READ);
read_info.io_desc_.set_wait_event(ObWaitEventIds::DB_FILE_DATA_READ);
read_info.io_desc_.set_group_id(ObIOModule::ROOT_BLOCK_IO);
if (OB_FAIL(addr.get_block_addr(read_info.macro_block_id_, read_info.offset_, read_info.size_))) {
LOG_WARN("fail to get block address", K(ret), K(addr));
} else if (OB_FAIL(ObBlockManager::read_block(read_info, handle))) {

2
src/storage/blocksstable/ob_tmp_file_cache.cpp
View File

@ -397,6 +397,7 @@ int ObTmpPageCache::read_io(const ObTmpBlockIOInfo &io_info, ObITmpPageIOCallbac
read_info.io_callback_ = &callback;
read_info.offset_ = io_info.offset_;
read_info.size_ = io_info.size_;
read_info.io_desc_.set_group_id(ObIOModule::TMP_PAGE_CACHE_IO);
if (OB_FAIL(ObBlockManager::async_read_block(read_info, handle))) {
STORAGE_LOG(WARN, "fail to async read block", K(ret), K(read_info));
}
@ -1376,6 +1377,7 @@ int ObTmpTenantMemBlockManager::write_io(
write_info.buffer_ = io_info.buf_;
write_info.offset_ = ObTmpMacroBlock::get_header_padding();
write_info.size_ = io_info.size_;
write_info.io_desc_.set_group_id(ObIOModule::TMP_TENANT_MEM_BLOCK_IO);
if (OB_FAIL(ObBlockManager::async_write_block(write_info, handle))) {
STORAGE_LOG(WARN, "Fail to async write block", K(ret), K(write_info), K(handle));
} else if (OB_FAIL(OB_SERVER_BLOCK_MGR.inc_ref(handle.get_macro_id()))) {

1
src/storage/blockstore/ob_shared_block_reader_writer.cpp
View File

@ -904,6 +904,7 @@ int ObSharedBlockReaderWriter::async_read(
ObMacroBlockReadInfo macro_read_info;
ObMacroBlockHandle macro_handle;
macro_read_info.io_desc_.set_wait_event(ObWaitEventIds::DB_FILE_COMPACT_READ);
macro_read_info.io_desc_.set_group_id(ObIOModule::SHARED_BLOCK_RW_IO);
macro_read_info.io_callback_ = read_info.io_callback_;
if (OB_UNLIKELY(!read_info.is_valid())) {
ret = OB_INVALID_ARGUMENT;

1
src/storage/compaction/ob_index_block_micro_iterator.cpp
View File

@ -174,6 +174,7 @@ int ObIndexBlockMicroIterator::init(
read_info.offset_ = sstable->get_macro_offset();
read_info.size_ = sstable->get_macro_read_size();
read_info.io_desc_.set_wait_event(ObWaitEventIds::DB_FILE_COMPACT_READ);
read_info.io_desc_.set_group_id(ObIOModule::INDEX_BLOCK_MICRO_ITER_IO);
if (OB_FAIL(ObBlockManager::async_read_block(read_info, macro_handle_))) {
LOG_WARN("async read block failed, ", K(ret), K(read_info), K(macro_id));
} else if (OB_FAIL(macro_handle_.wait(io_timeout_ms))) {

12
src/storage/direct_load/ob_direct_load_tmp_file.cpp
View File

@ -207,7 +207,7 @@ int ObDirectLoadTmpFileIOHandle::aio_read(char *buf, int64_t size)
} else {
io_info_.size_ = size;
io_info_.buf_ = buf;
io_info_.io_desc_.set_group_id(THIS_WORKER.get_group_id());
io_info_.io_desc_.set_group_id(ObIOModule::DIRECT_LOAD_IO);
io_info_.io_desc_.set_wait_event(ObWaitEventIds::DB_FILE_DATA_READ);
if (OB_FAIL(FILE_MANAGER_INSTANCE_V2.aio_read(io_info_, file_io_handle_))) {
if (OB_UNLIKELY(OB_ITER_END != ret)) {
@ -230,7 +230,7 @@ int ObDirectLoadTmpFileIOHandle::aio_pread(char *buf, int64_t size, int64_t offs
} else {
io_info_.size_ = size;
io_info_.buf_ = buf;
io_info_.io_desc_.set_group_id(THIS_WORKER.get_group_id());
io_info_.io_desc_.set_group_id(ObIOModule::DIRECT_LOAD_IO);
io_info_.io_desc_.set_wait_event(ObWaitEventIds::DB_FILE_DATA_READ);
if (OB_FAIL(FILE_MANAGER_INSTANCE_V2.aio_pread(io_info_, offset, file_io_handle_))) {
if (OB_UNLIKELY(OB_ITER_END != ret)) {
@ -253,7 +253,7 @@ int ObDirectLoadTmpFileIOHandle::read(char *buf, int64_t &size, int64_t timeout_
} else {
io_info_.size_ = size;
io_info_.buf_ = buf;
io_info_.io_desc_.set_group_id(THIS_WORKER.get_group_id());
io_info_.io_desc_.set_group_id(ObIOModule::DIRECT_LOAD_IO);
io_info_.io_desc_.set_wait_event(ObWaitEventIds::DB_FILE_DATA_READ);
if (OB_FAIL(FILE_MANAGER_INSTANCE_V2.read(io_info_, timeout_ms, file_io_handle_))) {
if (OB_UNLIKELY(OB_ITER_END != ret)) {
@ -278,7 +278,7 @@ int ObDirectLoadTmpFileIOHandle::pread(char *buf, int64_t &size, int64_t offset,
} else {
io_info_.size_ = size;
io_info_.buf_ = buf;
io_info_.io_desc_.set_group_id(THIS_WORKER.get_group_id());
io_info_.io_desc_.set_group_id(ObIOModule::DIRECT_LOAD_IO);
io_info_.io_desc_.set_wait_event(ObWaitEventIds::DB_FILE_DATA_READ);
if (OB_FAIL(FILE_MANAGER_INSTANCE_V2.pread(io_info_, offset, timeout_ms, file_io_handle_))) {
if (OB_UNLIKELY(OB_ITER_END != ret)) {
@ -303,7 +303,7 @@ int ObDirectLoadTmpFileIOHandle::aio_write(char *buf, int64_t size)
} else {
io_info_.size_ = size;
io_info_.buf_ = buf;
io_info_.io_desc_.set_group_id(THIS_WORKER.get_group_id());
io_info_.io_desc_.set_group_id(ObIOModule::DIRECT_LOAD_IO);
io_info_.io_desc_.set_wait_event(ObWaitEventIds::DB_FILE_INDEX_BUILD_WRITE);
if (OB_FAIL(FILE_MANAGER_INSTANCE_V2.aio_write(io_info_, file_io_handle_))) {
LOG_WARN("fail to do aio write to tmp file", KR(ret), K_(io_info));
@ -324,7 +324,7 @@ int ObDirectLoadTmpFileIOHandle::write(char *buf, int64_t size, int64_t timeout_
} else {
io_info_.size_ = size;
io_info_.buf_ = buf;
io_info_.io_desc_.set_group_id(THIS_WORKER.get_group_id());
io_info_.io_desc_.set_group_id(ObIOModule::DIRECT_LOAD_IO);
io_info_.io_desc_.set_wait_event(ObWaitEventIds::DB_FILE_INDEX_BUILD_WRITE);
if (OB_FAIL(FILE_MANAGER_INSTANCE_V2.write(io_info_, timeout_ms))) {
LOG_WARN("fail to do write to tmp file", KR(ret), K_(io_info));

1
src/storage/high_availability/ob_storage_ha_macro_block_writer.cpp
View File

@ -119,6 +119,7 @@ int ObStorageHAMacroBlockWriter::process(blocksstable::ObMacroBlocksWriteCtx &co
int64_t data_size = 0;
obrpc::ObCopyMacroBlockHeader header;
write_info.io_desc_.set_wait_event(ObWaitEventIds::DB_FILE_MIGRATE_WRITE);
write_info.io_desc_.set_group_id(ObIOModule::HA_MACRO_BLOCK_WRITER_IO);
if (OB_UNLIKELY(!is_inited_)) {
ret = OB_NOT_INIT;

1
src/storage/high_availability/ob_storage_ha_reader.cpp
View File

@ -755,6 +755,7 @@ int ObCopyMacroBlockObProducer::prefetch_()
read_info.offset_ = sstable_->get_macro_offset();
read_info.size_ = sstable_->get_macro_read_size();
read_info.io_desc_.set_wait_event(ObWaitEventIds::DB_FILE_MIGRATE_READ);
read_info.io_desc_.set_group_id(ObIOModule::HA_COPY_MACRO_BLOCK_IO);
if (OB_FAIL(ObBlockManager::async_read_block(read_info, copy_macro_block_handle_[handle_idx_].read_handle_))) {
STORAGE_LOG(WARN, "Fail to async read block, ", K(ret), K(read_info));
}

1
src/storage/ob_bloom_filter_task.cpp
View File

@ -153,6 +153,7 @@ int ObBloomFilterBuildTask::build_bloom_filter()
read_info.offset_ = 0;
read_info.size_ = OB_DEFAULT_MACRO_BLOCK_SIZE;
read_info.io_desc_.set_wait_event(ObWaitEventIds::DB_FILE_DATA_READ);
read_info.io_desc_.set_group_id(ObIOModule::BLOOM_FILTER_IO);
if (OB_FAIL(ObBlockManager::read_block(read_info, macro_handle))) {
LOG_WARN("Fail to read macro block", K(ret), K(read_info));
} else if (OB_FAIL(macro_bare_iter->open(

4
src/storage/slog_ckpt/ob_linked_macro_block_reader.cpp
View File

@ -59,6 +59,7 @@ int ObLinkedMacroBlockReader::get_meta_blocks(const MacroBlockId &entry_block)
read_info.size_ = sizeof(ObMacroBlockCommonHeader) + sizeof(ObLinkedMacroBlockHeader);
read_info.io_desc_.set_mode(ObIOMode::READ);
read_info.io_desc_.set_wait_event(ObWaitEventIds::DB_FILE_DATA_READ);
read_info.io_desc_.set_group_id(ObIOModule::LINKED_MACRO_BLOCK_IO);
if (entry_block.second_id() >= 0) {
read_info.macro_block_id_ = entry_block;
int64_t handle_pos = 0;
@ -109,6 +110,7 @@ int ObLinkedMacroBlockReader::prefetch_block()
read_info.size_ = OB_SERVER_BLOCK_MGR.get_macro_block_size();
read_info.io_desc_.set_mode(ObIOMode::READ);
read_info.io_desc_.set_wait_event(ObWaitEventIds::DB_FILE_DATA_READ);
read_info.io_desc_.set_group_id(ObIOModule::LINKED_MACRO_BLOCK_IO);
read_info.macro_block_id_ = macros_handle_.at(prefetch_macro_block_idx_);
handles_[handle_pos_].reset();
if (OB_FAIL(ObBlockManager::async_read_block(read_info, handles_[handle_pos_]))) {
@ -152,6 +154,7 @@ int ObLinkedMacroBlockReader::pread_block(const ObMetaDiskAddr &addr, ObMacroBlo
handler.reset();
read_info.io_desc_.set_mode(ObIOMode::READ);
read_info.io_desc_.set_wait_event(ObWaitEventIds::DB_FILE_DATA_READ);
read_info.io_desc_.set_group_id(ObIOModule::LINKED_MACRO_BLOCK_IO);
if (OB_FAIL(addr.get_block_addr(read_info.macro_block_id_, read_info.offset_, read_info.size_))) {
LOG_WARN("fail to get block address", K(ret), K(addr));
} else if (OB_FAIL(ObBlockManager::async_read_block(read_info, handler))) {
@ -172,6 +175,7 @@ int ObLinkedMacroBlockReader::read_block_by_id(
read_info.size_ = OB_SERVER_BLOCK_MGR.get_macro_block_size();
read_info.io_desc_.set_mode(ObIOMode::READ);
read_info.io_desc_.set_wait_event(ObWaitEventIds::DB_FILE_DATA_READ);
read_info.io_desc_.set_group_id(ObIOModule::LINKED_MACRO_BLOCK_IO);
read_info.macro_block_id_ = block_id;
handler.reset();
if (OB_FAIL(ObBlockManager::async_read_block(read_info, handler))) {

1
src/storage/slog_ckpt/ob_linked_macro_block_writer.cpp
View File

@ -64,6 +64,7 @@ int ObLinkedMacroBlockWriter::write_block(const char *buf, const int64_t buf_len
write_info.size_ = macro_block_size;
write_info.io_desc_ = io_desc_;
write_info.buffer_ = buf;
write_info.io_desc_.set_group_id(ObIOModule::LINKED_MACRO_BLOCK_IO);
MacroBlockId previous_block_id;
previous_block_id.set_block_index(MacroBlockId::EMPTY_ENTRY_BLOCK_INDEX);
if (!handle_.is_empty()) {

2
unittest/storage/test_io_manager.cpp
View File

@ -1396,7 +1396,7 @@ void write_group_perf_config()
"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"
"1001 1 20001 r 16384 10 rolling 0 16 0 0 6\n"
"1002 1 0 r 16384 10 rolling 0 16 0 0 5\n"
;
const int64_t file_len = strlen(file_buf);