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

[parameter optimization] remove the class of checker about the range

Browse Source
This commit is contained in:
obdev 2023-06-22 00:12:41 +00:00 committed by ob-robot
parent e15d90acc7
commit ab34841bd6
4 changed files with 111 additions and 104 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

100
src/share/config/ob_config.cpp
View File

@ -55,6 +55,38 @@ const char *log_archive_encryption_algorithm_values[] =
"",
};
template<typename T>
static bool check_range(const ObConfigRangeOpts left_opt,
const ObConfigRangeOpts right_opt,
T &&value,
T &&min_value,
T &&max_value)
{
bool left_ret = true;
bool right_ret = true;
if (ObConfigRangeOpts::OB_CONF_RANGE_NONE == left_opt) {
// do nothing
} else if (ObConfigRangeOpts::OB_CONF_RANGE_GREATER_THAN == left_opt) {
left_ret = value > min_value;
} else if (ObConfigRangeOpts::OB_CONF_RANGE_GREATER_EQUAL == left_opt) {
left_ret = value >= min_value;
} else {
left_ret = false;
}
if (left_ret) {
if (ObConfigRangeOpts::OB_CONF_RANGE_NONE == right_opt) {
// do nothing
} else if (ObConfigRangeOpts::OB_CONF_RANGE_LESS_THAN == right_opt) {
right_ret = value < max_value;
} else if (ObConfigRangeOpts::OB_CONF_RANGE_LESS_EQUAL == right_opt) {
right_ret = value <= max_value;
} else {
right_ret = false;
}
}
return left_ret && right_ret;
}
// ObConfigItem
ObConfigItem::ObConfigItem()
: ck_(NULL), version_(0), dumped_version_(0), inited_(false), initial_value_set_(false),
@ -344,23 +376,27 @@ bool ObConfigIntegralItem::parse_range(const char *range)
*p_middle = '\0';
if ('\0' != p_left[1]) {
parse(p_left + 1, valid);
int64_t val_left = parse(p_left + 1, valid);
if (valid) {
if (*p_left == '(') {
add_checker(OB_NEW(ObConfigGreaterThan, g_config_mem_attr, p_left + 1));
min_value_ = val_left;
left_interval_opt_ = ObConfigRangeOpts::OB_CONF_RANGE_GREATER_THAN;
} else if (*p_left == '[') {
add_checker(OB_NEW(ObConfigGreaterEqual, g_config_mem_attr, p_left + 1));
min_value_ = val_left;
left_interval_opt_ = ObConfigRangeOpts::OB_CONF_RANGE_GREATER_EQUAL;
}
}
}
if ('\0' != p_middle[1]) {
parse(p_middle + 1, valid);
int64_t val_right = parse(p_middle + 1, valid);
if (valid) {
if (')' == ch_right) {
add_checker(OB_NEW(ObConfigLessThan, g_config_mem_attr, p_middle + 1));
max_value_ = val_right;
right_interval_opt_ = ObConfigRangeOpts::OB_CONF_RANGE_LESS_THAN;
} else if (']' == ch_right) {
add_checker(OB_NEW(ObConfigLessEqual, g_config_mem_attr, p_middle + 1));
max_value_ = val_right;
right_interval_opt_ = ObConfigRangeOpts::OB_CONF_RANGE_LESS_EQUAL;
}
}
}
@ -371,6 +407,20 @@ bool ObConfigIntegralItem::parse_range(const char *range)
return bool_ret;
}
bool ObConfigIntegralItem::check() const
{
// check order: value_valid_ --> range --> customized checker (for DEF_XXX_WITH_CHECKER)
bool bool_ret = false;
if (!value_valid_) {
} else if (!check_range(left_interval_opt_, right_interval_opt_,
value_, min_value_, max_value_)) {
} else if (ck_ && !ck_->check(*this)) {
} else {
bool_ret = true;
}
return bool_ret;
}
// ObConfigDoubleItem
ObConfigDoubleItem::ObConfigDoubleItem(ObConfigContainer *container,
Scope::ScopeInfo scope_info,
@ -379,7 +429,9 @@ ObConfigDoubleItem::ObConfigDoubleItem(ObConfigContainer *container,
const char *range,
const char *info,
const ObParameterAttr attr)
: value_(0)
: value_(0), min_value_(0), max_value_(0),
left_interval_opt_(ObConfigRangeOpts::OB_CONF_RANGE_NONE),
right_interval_opt_(ObConfigRangeOpts::OB_CONF_RANGE_NONE)
{
MEMSET(value_str_, 0, sizeof(value_str_));
MEMSET(value_reboot_str_, 0, sizeof(value_reboot_str_));
@ -395,7 +447,9 @@ ObConfigDoubleItem::ObConfigDoubleItem(ObConfigContainer *container,
const char *def,
const char *info,
const ObParameterAttr attr)
: value_(0)
: value_(0), min_value_(0), max_value_(0),
left_interval_opt_(ObConfigRangeOpts::OB_CONF_RANGE_NONE),
right_interval_opt_(ObConfigRangeOpts::OB_CONF_RANGE_NONE)
{
MEMSET(value_str_, 0, sizeof(value_str_));
MEMSET(value_reboot_str_, 0, sizeof(value_reboot_str_));
@ -475,21 +529,25 @@ bool ObConfigDoubleItem::parse_range(const char *range)
*p_right = '\0';
*p_middle = '\0';
parse(p_left + 1, valid);
double val_left = parse(p_left + 1, valid);
if (valid) {
if (*p_left == '(') {
add_checker(OB_NEW(ObConfigGreaterThan, g_config_mem_attr, p_left + 1));
min_value_ = val_left;
left_interval_opt_ = ObConfigRangeOpts::OB_CONF_RANGE_GREATER_THAN;
} else if (*p_left == '[') {
add_checker(OB_NEW(ObConfigGreaterEqual, g_config_mem_attr, p_left + 1));
min_value_ = val_left;
left_interval_opt_ = ObConfigRangeOpts::OB_CONF_RANGE_GREATER_EQUAL;
}
}
parse(p_middle + 1, valid);
double val_right = parse(p_middle + 1, valid);
if (valid) {
if (')' == ch_right) {
add_checker(OB_NEW(ObConfigLessThan, g_config_mem_attr, p_middle + 1));
max_value_ = val_right;
right_interval_opt_ = ObConfigRangeOpts::OB_CONF_RANGE_LESS_THAN;
} else if (']' == ch_right) {
add_checker(OB_NEW(ObConfigLessEqual, g_config_mem_attr, p_middle + 1));
max_value_ = val_right;
right_interval_opt_ = ObConfigRangeOpts::OB_CONF_RANGE_LESS_EQUAL;
}
}
bool_ret = true;
@ -498,6 +556,20 @@ bool ObConfigDoubleItem::parse_range(const char *range)
return bool_ret;
}
bool ObConfigDoubleItem::check() const
{
// check order: value_valid_ --> range --> customized checker (for DEF_XXX_WITH_CHECKER)
bool bool_ret = false;
if (!value_valid_) {
} else if (!check_range(left_interval_opt_, right_interval_opt_,
value_, min_value_, max_value_)) {
} else if (ck_ && !ck_->check(*this)) {
} else {
bool_ret = true;
}
return bool_ret;
}
// ObConfigCapacityItem
ObConfigCapacityItem::ObConfigCapacityItem(ObConfigContainer *container,
Scope::ScopeInfo scope_info,

27
src/share/config/ob_config.h
View File

@ -49,6 +49,14 @@ enum ObConfigItemType{
OB_CONF_ITEM_TYPE_VERSION = 11,
};
enum class ObConfigRangeOpts {
OB_CONF_RANGE_NONE,
OB_CONF_RANGE_GREATER_THAN,
OB_CONF_RANGE_GREATER_EQUAL,
OB_CONF_RANGE_LESS_THAN,
OB_CONF_RANGE_LESS_EQUAL,
};
extern ObMemAttr g_config_mem_attr;
class ObConfigItem
{
@ -65,7 +73,7 @@ public:
{
ck_ = OB_NEW(ObConfigConsChecker, g_config_mem_attr, ck_, new_ck);
}
bool check() const
virtual bool check() const
{
return NULL == ck_ ? value_valid_ : value_valid_ && ck_->check(*this);
}
@ -437,7 +445,12 @@ class ObConfigIntegralItem
: public ObConfigItem
{
public:
ObConfigIntegralItem() : value_(0) {}
ObConfigIntegralItem()
: value_(0), min_value_(0), max_value_(0),
left_interval_opt_(ObConfigRangeOpts::OB_CONF_RANGE_NONE),
right_interval_opt_(ObConfigRangeOpts::OB_CONF_RANGE_NONE)
{
}
virtual ~ObConfigIntegralItem() {}
bool operator >(const char *str) const
@ -465,6 +478,7 @@ public:
virtual ObConfigItemType get_config_item_type() const {
return ObConfigItemType::OB_CONF_ITEM_TYPE_INTEGRAL;
}
virtual bool check() const override;
protected:
//use current value to do input operation
virtual bool set(const char *str);
@ -472,6 +486,10 @@ protected:
private:
int64_t value_;
int64_t min_value_;
int64_t max_value_;
ObConfigRangeOpts left_interval_opt_;
ObConfigRangeOpts right_interval_opt_;
DISALLOW_COPY_AND_ASSIGN(ObConfigIntegralItem);
};
inline bool ObConfigIntegralItem::set(const char *str)
@ -530,6 +548,7 @@ public:
virtual ObConfigItemType get_config_item_type() const {
return ObConfigItemType::OB_CONF_ITEM_TYPE_DOUBLE;
}
virtual bool check() const override;
protected:
//use current value to do input operation
@ -558,6 +577,10 @@ protected:
private:
double value_;
double min_value_;
double max_value_;
ObConfigRangeOpts left_interval_opt_;
ObConfigRangeOpts right_interval_opt_;
DISALLOW_COPY_AND_ASSIGN(ObConfigDoubleItem);
};
inline ObConfigDoubleItem &ObConfigDoubleItem::operator = (double value)

20
src/share/config/ob_config_helper.cpp
View File

@ -59,26 +59,6 @@ bool ObConfigConsChecker::check(const ObConfigItem &t) const
&& (NULL == right_ ? true : right_->check(t));
}
bool ObConfigGreaterThan::check(const ObConfigItem &t) const
{
return t > val_;
}
bool ObConfigGreaterEqual::check(const ObConfigItem &t) const
{
return t >= val_;
}
bool ObConfigLessThan::check(const ObConfigItem &t) const
{
return t < val_;
}
bool ObConfigLessEqual::check(const ObConfigItem &t) const
{
return t <= val_;
}
bool ObConfigEvenIntChecker::check(const ObConfigItem &t) const
{
bool is_valid = false;

68
src/share/config/ob_config_helper.h
View File

@ -83,74 +83,6 @@ private:
DISALLOW_COPY_AND_ASSIGN(ObConfigConsChecker);
};
class ObConfigBinaryChecker
: public ObConfigChecker
{
public:
explicit ObConfigBinaryChecker(const char *str);
virtual ~ObConfigBinaryChecker() {}
const char *value() const { return val_; }
protected:
char val_[OB_MAX_CONFIG_VALUE_LEN];
private:
DISALLOW_COPY_AND_ASSIGN(ObConfigBinaryChecker);
};
inline ObConfigBinaryChecker::ObConfigBinaryChecker(const char *str)
{
int64_t pos = 0;
(void) databuff_printf(val_, sizeof(val_), pos, "%s", str);
}
class ObConfigGreaterThan
: public ObConfigBinaryChecker
{
public:
explicit ObConfigGreaterThan(const char *str) : ObConfigBinaryChecker(str) {}
virtual ~ObConfigGreaterThan() {}
bool check(const ObConfigItem &t) const;
private:
DISALLOW_COPY_AND_ASSIGN(ObConfigGreaterThan);
};
class ObConfigGreaterEqual
: public ObConfigBinaryChecker
{
public:
explicit ObConfigGreaterEqual(const char *str) : ObConfigBinaryChecker(str) {}
virtual ~ObConfigGreaterEqual() {}
bool check(const ObConfigItem &t) const;
private:
DISALLOW_COPY_AND_ASSIGN(ObConfigGreaterEqual);
};
class ObConfigLessThan
: public ObConfigBinaryChecker
{
public:
explicit ObConfigLessThan(const char *str) : ObConfigBinaryChecker(str) {}
virtual ~ObConfigLessThan() {}
bool check(const ObConfigItem &t) const;
private:
DISALLOW_COPY_AND_ASSIGN(ObConfigLessThan);
};
class ObConfigLessEqual
: public ObConfigBinaryChecker
{
public:
explicit ObConfigLessEqual(const char *str) : ObConfigBinaryChecker(str) {}
virtual ~ObConfigLessEqual() {}
bool check(const ObConfigItem &t) const;
private:
DISALLOW_COPY_AND_ASSIGN(ObConfigLessEqual);
};
class ObConfigEvenIntChecker
: public ObConfigChecker
{