From b05e449af5ff6bf9eb702f5b8d6fe4ff69603811 Mon Sep 17 00:00:00 2001 From: Xinye Tao Date: Thu, 2 Jun 2022 10:32:27 +0800 Subject: [PATCH] engine: only override write stall configurations if unspecified (#12127) ref tikv/tikv#11424, ref tikv/tikv#11840 Signed-off-by: tabokie --- etc/config-template.toml | 20 +- src/config.rs | 311 +++++++++++++++++++++++-------- tests/integrations/config/mod.rs | 40 ++-- 3 files changed, 268 insertions(+), 103 deletions(-) diff --git a/etc/config-template.toml b/etc/config-template.toml index 073287878ad..ebaf8e30135 100644 --- a/etc/config-template.toml +++ b/etc/config-template.toml @@ -667,7 +667,7 @@ ## Maximum number of level-0 files. ## When the number of SST files of level-0 reaches the limit of `level0-stop-writes-trigger`, ## RocksDB stalls the new write operation. -# level0-stop-writes-trigger = 36 +# level0-stop-writes-trigger = 20 ## Amount of data to build up in memory (backed by an unsorted log on disk) before converting to a ## sorted on-disk file. It is the RocksDB MemTable size. @@ -719,6 +719,12 @@ ## "min-overlapping-ratio" # compaction-pri = "min-overlapping-ratio" +## Refer to storage.flow-control.soft-pending-compaction-bytes-limit. +# soft-pending-compaction-bytes-limit = "192GB" + +## Refer to storage.flow-control.hard-pending-compaction-bytes-limit. +# hard-pending-compaction-bytes-limit = "1000GB" + ## Indicating if we'd put index/filter blocks to the block cache. ## If not specified, each "table reader" object will pre-load index/filter block during table ## initialization. @@ -833,10 +839,12 @@ # level0-file-num-compaction-trigger = 4 # level0-slowdown-writes-trigger = 20 -# level0-stop-writes-trigger = 36 +# level0-stop-writes-trigger = 20 # cache-index-and-filter-blocks = true # pin-l0-filter-and-index-blocks = true # compaction-pri = "min-overlapping-ratio" +# soft-pending-compaction-bytes-limit = "192GB" +# hard-pending-compaction-bytes-limit = "1000GB" # read-amp-bytes-per-bit = 0 # dynamic-level-bytes = true # optimize-filters-for-hits = false @@ -854,10 +862,12 @@ # target-file-size-base = "8MB" # level0-file-num-compaction-trigger = 1 # level0-slowdown-writes-trigger = 20 -# level0-stop-writes-trigger = 36 +# level0-stop-writes-trigger = 20 # cache-index-and-filter-blocks = true # pin-l0-filter-and-index-blocks = true # compaction-pri = "by-compensated-size" +# soft-pending-compaction-bytes-limit = "192GB" +# hard-pending-compaction-bytes-limit = "1000GB" # read-amp-bytes-per-bit = 0 # dynamic-level-bytes = true # optimize-filters-for-hits = false @@ -911,10 +921,12 @@ # level0-file-num-compaction-trigger = 4 # level0-slowdown-writes-trigger = 20 -# level0-stop-writes-trigger = 36 +# level0-stop-writes-trigger = 20 # cache-index-and-filter-blocks = true # pin-l0-filter-and-index-blocks = true # compaction-pri = "by-compensated-size" +# soft-pending-compaction-bytes-limit = "192GB" +# hard-pending-compaction-bytes-limit = "1000GB" # read-amp-bytes-per-bit = 0 # dynamic-level-bytes = true # optimize-filters-for-hits = true diff --git a/src/config.rs b/src/config.rs index de9cf602977..623622b06c1 100644 --- a/src/config.rs +++ b/src/config.rs @@ -262,8 +262,8 @@ macro_rules! cf_config { pub max_bytes_for_level_base: ReadableSize, pub target_file_size_base: ReadableSize, pub level0_file_num_compaction_trigger: i32, - pub level0_slowdown_writes_trigger: i32, - pub level0_stop_writes_trigger: i32, + pub level0_slowdown_writes_trigger: Option, + pub level0_stop_writes_trigger: Option, pub max_compaction_bytes: ReadableSize, #[serde(with = "rocks_config::compaction_pri_serde")] #[online_config(skip)] @@ -278,8 +278,8 @@ macro_rules! cf_config { pub compaction_style: DBCompactionStyle, pub disable_auto_compactions: bool, pub disable_write_stall: bool, - pub soft_pending_compaction_bytes_limit: ReadableSize, - pub hard_pending_compaction_bytes_limit: ReadableSize, + pub soft_pending_compaction_bytes_limit: Option, + pub hard_pending_compaction_bytes_limit: Option, #[online_config(skip)] pub force_consistency_checks: bool, #[online_config(skip)] @@ -380,10 +380,14 @@ macro_rules! write_into_metrics { .set($cf.level0_file_num_compaction_trigger.into()); $metrics .with_label_values(&[$tag, "level0_slowdown_writes_trigger"]) - .set($cf.level0_slowdown_writes_trigger.into()); + .set( + $cf.level0_slowdown_writes_trigger + .unwrap_or_default() + .into(), + ); $metrics .with_label_values(&[$tag, "level0_stop_writes_trigger"]) - .set($cf.level0_stop_writes_trigger.into()); + .set($cf.level0_stop_writes_trigger.unwrap_or_default().into()); $metrics .with_label_values(&[$tag, "max_compaction_bytes"]) .set($cf.max_compaction_bytes.0 as f64); @@ -405,10 +409,18 @@ macro_rules! write_into_metrics { .set(($cf.disable_write_stall as i32).into()); $metrics .with_label_values(&[$tag, "soft_pending_compaction_bytes_limit"]) - .set($cf.soft_pending_compaction_bytes_limit.0 as f64); + .set( + $cf.soft_pending_compaction_bytes_limit + .unwrap_or_default() + .0 as f64, + ); $metrics .with_label_values(&[$tag, "hard_pending_compaction_bytes_limit"]) - .set($cf.hard_pending_compaction_bytes_limit.0 as f64); + .set( + $cf.hard_pending_compaction_bytes_limit + .unwrap_or_default() + .0 as f64, + ); $metrics .with_label_values(&[$tag, "force_consistency_checks"]) .set(($cf.force_consistency_checks as i32).into()); @@ -484,8 +496,12 @@ macro_rules! build_cf_opt { cf_opts.set_max_bytes_for_level_base($opt.max_bytes_for_level_base.0); cf_opts.set_target_file_size_base($opt.target_file_size_base.0); cf_opts.set_level_zero_file_num_compaction_trigger($opt.level0_file_num_compaction_trigger); - cf_opts.set_level_zero_slowdown_writes_trigger($opt.level0_slowdown_writes_trigger); - cf_opts.set_level_zero_stop_writes_trigger($opt.level0_stop_writes_trigger); + cf_opts.set_level_zero_slowdown_writes_trigger( + $opt.level0_slowdown_writes_trigger.unwrap_or_default(), + ); + cf_opts.set_level_zero_stop_writes_trigger( + $opt.level0_stop_writes_trigger.unwrap_or_default(), + ); cf_opts.set_max_compaction_bytes($opt.max_compaction_bytes.0); cf_opts.compaction_priority($opt.compaction_pri); cf_opts.set_level_compaction_dynamic_level_bytes($opt.dynamic_level_bytes); @@ -493,8 +509,16 @@ macro_rules! build_cf_opt { cf_opts.set_compaction_style($opt.compaction_style); cf_opts.set_disable_auto_compactions($opt.disable_auto_compactions); cf_opts.set_disable_write_stall($opt.disable_write_stall); - cf_opts.set_soft_pending_compaction_bytes_limit($opt.soft_pending_compaction_bytes_limit.0); - cf_opts.set_hard_pending_compaction_bytes_limit($opt.hard_pending_compaction_bytes_limit.0); + cf_opts.set_soft_pending_compaction_bytes_limit( + $opt.soft_pending_compaction_bytes_limit + .unwrap_or_default() + .0, + ); + cf_opts.set_hard_pending_compaction_bytes_limit( + $opt.hard_pending_compaction_bytes_limit + .unwrap_or_default() + .0, + ); cf_opts.set_optimize_filters_for_hits($opt.optimize_filters_for_hits); cf_opts.set_force_consistency_checks($opt.force_consistency_checks); if $opt.enable_doubly_skiplist { @@ -551,8 +575,8 @@ impl Default for DefaultCfConfig { max_bytes_for_level_base: ReadableSize::mb(512), target_file_size_base: ReadableSize::mb(8), level0_file_num_compaction_trigger: 4, - level0_slowdown_writes_trigger: 20, - level0_stop_writes_trigger: 36, + level0_slowdown_writes_trigger: None, + level0_stop_writes_trigger: None, max_compaction_bytes: ReadableSize::gb(2), compaction_pri: CompactionPriority::MinOverlappingRatio, dynamic_level_bytes: true, @@ -561,8 +585,8 @@ impl Default for DefaultCfConfig { compaction_style: DBCompactionStyle::Level, disable_auto_compactions: false, disable_write_stall: false, - soft_pending_compaction_bytes_limit: ReadableSize::gb(192), - hard_pending_compaction_bytes_limit: ReadableSize::gb(256), + soft_pending_compaction_bytes_limit: None, + hard_pending_compaction_bytes_limit: None, force_consistency_checks: false, prop_size_index_distance: DEFAULT_PROP_SIZE_INDEX_DISTANCE, prop_keys_index_distance: DEFAULT_PROP_KEYS_INDEX_DISTANCE, @@ -655,8 +679,8 @@ impl Default for WriteCfConfig { max_bytes_for_level_base: ReadableSize::mb(512), target_file_size_base: ReadableSize::mb(8), level0_file_num_compaction_trigger: 4, - level0_slowdown_writes_trigger: 20, - level0_stop_writes_trigger: 36, + level0_slowdown_writes_trigger: None, + level0_stop_writes_trigger: None, max_compaction_bytes: ReadableSize::gb(2), compaction_pri: CompactionPriority::MinOverlappingRatio, dynamic_level_bytes: true, @@ -665,8 +689,8 @@ impl Default for WriteCfConfig { compaction_style: DBCompactionStyle::Level, disable_auto_compactions: false, disable_write_stall: false, - soft_pending_compaction_bytes_limit: ReadableSize::gb(192), - hard_pending_compaction_bytes_limit: ReadableSize::gb(256), + soft_pending_compaction_bytes_limit: None, + hard_pending_compaction_bytes_limit: None, force_consistency_checks: false, prop_size_index_distance: DEFAULT_PROP_SIZE_INDEX_DISTANCE, prop_keys_index_distance: DEFAULT_PROP_KEYS_INDEX_DISTANCE, @@ -748,8 +772,8 @@ impl Default for LockCfConfig { max_bytes_for_level_base: ReadableSize::mb(128), target_file_size_base: ReadableSize::mb(8), level0_file_num_compaction_trigger: 1, - level0_slowdown_writes_trigger: 20, - level0_stop_writes_trigger: 36, + level0_slowdown_writes_trigger: None, + level0_stop_writes_trigger: None, max_compaction_bytes: ReadableSize::gb(2), compaction_pri: CompactionPriority::ByCompensatedSize, dynamic_level_bytes: true, @@ -758,8 +782,8 @@ impl Default for LockCfConfig { compaction_style: DBCompactionStyle::Level, disable_auto_compactions: false, disable_write_stall: false, - soft_pending_compaction_bytes_limit: ReadableSize::gb(192), - hard_pending_compaction_bytes_limit: ReadableSize::gb(256), + soft_pending_compaction_bytes_limit: None, + hard_pending_compaction_bytes_limit: None, force_consistency_checks: false, prop_size_index_distance: DEFAULT_PROP_SIZE_INDEX_DISTANCE, prop_keys_index_distance: DEFAULT_PROP_KEYS_INDEX_DISTANCE, @@ -822,8 +846,8 @@ impl Default for RaftCfConfig { max_bytes_for_level_base: ReadableSize::mb(128), target_file_size_base: ReadableSize::mb(8), level0_file_num_compaction_trigger: 1, - level0_slowdown_writes_trigger: 20, - level0_stop_writes_trigger: 36, + level0_slowdown_writes_trigger: None, + level0_stop_writes_trigger: None, max_compaction_bytes: ReadableSize::gb(2), compaction_pri: CompactionPriority::ByCompensatedSize, dynamic_level_bytes: true, @@ -832,8 +856,8 @@ impl Default for RaftCfConfig { compaction_style: DBCompactionStyle::Level, disable_auto_compactions: false, disable_write_stall: false, - soft_pending_compaction_bytes_limit: ReadableSize::gb(192), - hard_pending_compaction_bytes_limit: ReadableSize::gb(256), + soft_pending_compaction_bytes_limit: None, + hard_pending_compaction_bytes_limit: None, force_consistency_checks: false, prop_size_index_distance: DEFAULT_PROP_SIZE_INDEX_DISTANCE, prop_keys_index_distance: DEFAULT_PROP_KEYS_INDEX_DISTANCE, @@ -1188,8 +1212,8 @@ impl Default for RaftDefaultCfConfig { max_bytes_for_level_base: ReadableSize::mb(512), target_file_size_base: ReadableSize::mb(8), level0_file_num_compaction_trigger: 4, - level0_slowdown_writes_trigger: 20, - level0_stop_writes_trigger: 36, + level0_slowdown_writes_trigger: None, + level0_stop_writes_trigger: None, max_compaction_bytes: ReadableSize::gb(2), compaction_pri: CompactionPriority::ByCompensatedSize, dynamic_level_bytes: true, @@ -1198,8 +1222,8 @@ impl Default for RaftDefaultCfConfig { compaction_style: DBCompactionStyle::Level, disable_auto_compactions: false, disable_write_stall: false, - soft_pending_compaction_bytes_limit: ReadableSize::gb(192), - hard_pending_compaction_bytes_limit: ReadableSize::gb(256), + soft_pending_compaction_bytes_limit: None, + hard_pending_compaction_bytes_limit: None, force_consistency_checks: false, prop_size_index_distance: DEFAULT_PROP_SIZE_INDEX_DISTANCE, prop_keys_index_distance: DEFAULT_PROP_KEYS_INDEX_DISTANCE, @@ -2710,58 +2734,81 @@ impl TiKvConfig { self.resource_metering.validate()?; if self.storage.flow_control.enable { - // using raftdb write stall to control memtables as a safety net - self.raftdb.defaultcf.level0_slowdown_writes_trigger = 10000; - self.raftdb.defaultcf.level0_stop_writes_trigger = 10000; - self.raftdb.defaultcf.soft_pending_compaction_bytes_limit = ReadableSize(0); - self.raftdb.defaultcf.hard_pending_compaction_bytes_limit = ReadableSize(0); - - // disable kvdb write stall, and override related configs self.rocksdb.defaultcf.disable_write_stall = true; - self.rocksdb.defaultcf.level0_slowdown_writes_trigger = - self.storage.flow_control.l0_files_threshold as i32; - self.rocksdb.defaultcf.soft_pending_compaction_bytes_limit = self - .storage - .flow_control - .soft_pending_compaction_bytes_limit; - self.rocksdb.defaultcf.hard_pending_compaction_bytes_limit = self - .storage - .flow_control - .hard_pending_compaction_bytes_limit; self.rocksdb.writecf.disable_write_stall = true; - self.rocksdb.writecf.level0_slowdown_writes_trigger = - self.storage.flow_control.l0_files_threshold as i32; - self.rocksdb.writecf.soft_pending_compaction_bytes_limit = self - .storage - .flow_control - .soft_pending_compaction_bytes_limit; - self.rocksdb.writecf.hard_pending_compaction_bytes_limit = self - .storage - .flow_control - .hard_pending_compaction_bytes_limit; self.rocksdb.lockcf.disable_write_stall = true; - self.rocksdb.lockcf.level0_slowdown_writes_trigger = - self.storage.flow_control.l0_files_threshold as i32; - self.rocksdb.lockcf.soft_pending_compaction_bytes_limit = self - .storage - .flow_control - .soft_pending_compaction_bytes_limit; - self.rocksdb.lockcf.hard_pending_compaction_bytes_limit = self - .storage - .flow_control - .hard_pending_compaction_bytes_limit; self.rocksdb.raftcf.disable_write_stall = true; - self.rocksdb.raftcf.level0_slowdown_writes_trigger = - self.storage.flow_control.l0_files_threshold as i32; - self.rocksdb.raftcf.soft_pending_compaction_bytes_limit = self - .storage - .flow_control - .soft_pending_compaction_bytes_limit; - self.rocksdb.raftcf.hard_pending_compaction_bytes_limit = self - .storage - .flow_control - .hard_pending_compaction_bytes_limit; } + // Fill in values for unspecified write stall configurations. + macro_rules! fill_cf_opts { + ($cf_opts:expr, $cfg:expr) => { + if let Some(v) = &mut $cf_opts.level0_slowdown_writes_trigger { + if $cfg.enable && *v > $cfg.l0_files_threshold as i32 { + warn!( + "{}.level0-slowdown-writes-trigger is too large. Setting it to \ + storage.flow-control.l0-files-threshold ({})", + stringify!($cf_opts), $cfg.l0_files_threshold + ); + *v = $cfg.l0_files_threshold as i32; + } + } else { + $cf_opts.level0_slowdown_writes_trigger = + Some($cfg.l0_files_threshold as i32); + } + if let Some(v) = &mut $cf_opts.level0_stop_writes_trigger { + if $cfg.enable && *v > $cfg.l0_files_threshold as i32 { + warn!( + "{}.level0-stop-writes-trigger is too large. Setting it to \ + storage.flow-control.l0-files-threshold ({})", + stringify!($cf_opts), $cfg.l0_files_threshold + ); + *v = $cfg.l0_files_threshold as i32; + } + } else { + $cf_opts.level0_stop_writes_trigger = + Some($cfg.l0_files_threshold as i32); + } + if let Some(v) = &mut $cf_opts.soft_pending_compaction_bytes_limit { + if $cfg.enable && v.0 > $cfg.soft_pending_compaction_bytes_limit.0 { + warn!( + "{}.soft-pending-compaction-bytes-limit is too large. Setting it to \ + storage.flow-control.soft-pending-compaction-bytes-limit ({})", + stringify!($cf_opts), $cfg.soft_pending_compaction_bytes_limit.0 + ); + *v = $cfg.soft_pending_compaction_bytes_limit; + } + } else { + $cf_opts.soft_pending_compaction_bytes_limit = + Some($cfg.soft_pending_compaction_bytes_limit); + } + if let Some(v) = &mut $cf_opts.hard_pending_compaction_bytes_limit { + if $cfg.enable && v.0 > $cfg.hard_pending_compaction_bytes_limit.0 { + warn!( + "{}.hard-pending-compaction-bytes-limit is too large. Setting it to \ + storage.flow-control.hard-pending-compaction-bytes-limit ({})", + stringify!($cf_opts), $cfg.hard_pending_compaction_bytes_limit.0 + ); + *v = $cfg.hard_pending_compaction_bytes_limit; + } + } else { + $cf_opts.hard_pending_compaction_bytes_limit = + Some($cfg.hard_pending_compaction_bytes_limit); + } + }; + } + let flow_control_cfg = if self.storage.flow_control.enable { + self.storage.flow_control.clone() + } else { + crate::storage::config::FlowControlConfig { + enable: false, + ..Default::default() + } + }; + fill_cf_opts!(self.raftdb.defaultcf, flow_control_cfg); + fill_cf_opts!(self.rocksdb.defaultcf, flow_control_cfg); + fill_cf_opts!(self.rocksdb.writecf, flow_control_cfg); + fill_cf_opts!(self.rocksdb.lockcf, flow_control_cfg); + fill_cf_opts!(self.rocksdb.raftcf, flow_control_cfg); if let Some(memory_usage_limit) = self.memory_usage_limit { let total = SysQuota::memory_limit_in_bytes(); @@ -4505,6 +4552,26 @@ mod tests { cfg.storage.block_cache.capacity = None; // Either `None` and a value is computed or `Some(_)` fixed value. cfg.memory_usage_limit = None; cfg.coprocessor_v2.coprocessor_plugin_directory = None; // Default is `None`, which is represented by not setting the key. + cfg.rocksdb.defaultcf.level0_slowdown_writes_trigger = None; + cfg.rocksdb.defaultcf.level0_stop_writes_trigger = None; + cfg.rocksdb.defaultcf.soft_pending_compaction_bytes_limit = None; + cfg.rocksdb.defaultcf.hard_pending_compaction_bytes_limit = None; + cfg.rocksdb.writecf.level0_slowdown_writes_trigger = None; + cfg.rocksdb.writecf.level0_stop_writes_trigger = None; + cfg.rocksdb.writecf.soft_pending_compaction_bytes_limit = None; + cfg.rocksdb.writecf.hard_pending_compaction_bytes_limit = None; + cfg.rocksdb.lockcf.level0_slowdown_writes_trigger = None; + cfg.rocksdb.lockcf.level0_stop_writes_trigger = None; + cfg.rocksdb.lockcf.soft_pending_compaction_bytes_limit = None; + cfg.rocksdb.lockcf.hard_pending_compaction_bytes_limit = None; + cfg.rocksdb.raftcf.level0_slowdown_writes_trigger = None; + cfg.rocksdb.raftcf.level0_stop_writes_trigger = None; + cfg.rocksdb.raftcf.soft_pending_compaction_bytes_limit = None; + cfg.rocksdb.raftcf.hard_pending_compaction_bytes_limit = None; + cfg.raftdb.defaultcf.level0_slowdown_writes_trigger = None; + cfg.raftdb.defaultcf.level0_stop_writes_trigger = None; + cfg.raftdb.defaultcf.soft_pending_compaction_bytes_limit = None; + cfg.raftdb.defaultcf.hard_pending_compaction_bytes_limit = None; assert_eq!(cfg, default_cfg); } @@ -4659,4 +4726,90 @@ mod tests { .contains("rate-limiter-mode = 1") ); } + + #[test] + fn test_flow_control_override() { + let content = r#" + [storage.flow-control] + enable = true + l0-files-threshold = 77 + soft-pending-compaction-bytes-limit = "777GB" + "#; + let mut cfg: TiKvConfig = toml::from_str(content).unwrap(); + cfg.validate().unwrap(); + assert_eq!( + cfg.rocksdb.defaultcf.level0_slowdown_writes_trigger, + Some(77) + ); + assert_eq!( + cfg.rocksdb.defaultcf.soft_pending_compaction_bytes_limit, + Some(ReadableSize::gb(777)) + ); + + // Override with default values if flow control is disabled. + let content = r#" + [storage.flow-control] + enable = false + l0-files-threshold = 77 + soft-pending-compaction-bytes-limit = "777GB" + [rocksdb.defaultcf] + level0-slowdown-writes-trigger = 888 + soft-pending-compaction-bytes-limit = "888GB" + [rocksdb.writecf] + "#; + let mut cfg: TiKvConfig = toml::from_str(content).unwrap(); + cfg.validate().unwrap(); + assert_eq!( + cfg.rocksdb.defaultcf.level0_slowdown_writes_trigger, + Some(888) + ); + assert_eq!( + cfg.rocksdb.defaultcf.soft_pending_compaction_bytes_limit, + Some(ReadableSize::gb(888)) + ); + matches!(cfg.rocksdb.writecf.level0_slowdown_writes_trigger, Some(v) if v != 77); + matches!(cfg.rocksdb.writecf.soft_pending_compaction_bytes_limit, Some(v) if v != ReadableSize::gb(777)); + + // Do not override when RocksDB configurations are specified. + let content = r#" + [storage.flow-control] + enable = true + l0-files-threshold = 77 + soft-pending-compaction-bytes-limit = "777GB" + [rocksdb.defaultcf] + level0-slowdown-writes-trigger = 66 + soft-pending-compaction-bytes-limit = "666GB" + "#; + let mut cfg: TiKvConfig = toml::from_str(content).unwrap(); + cfg.validate().unwrap(); + assert_eq!( + cfg.rocksdb.defaultcf.level0_slowdown_writes_trigger, + Some(66) + ); + assert_eq!( + cfg.rocksdb.defaultcf.soft_pending_compaction_bytes_limit, + Some(ReadableSize::gb(666)) + ); + + // Cannot specify larger configurations for RocksDB. + let content = r#" + [storage.flow-control] + enable = true + l0-files-threshold = 1 + soft-pending-compaction-bytes-limit = "1GB" + [rocksdb.defaultcf] + level0-slowdown-writes-trigger = 88 + soft-pending-compaction-bytes-limit = "888GB" + "#; + let mut cfg: TiKvConfig = toml::from_str(content).unwrap(); + cfg.validate().unwrap(); + assert_eq!( + cfg.rocksdb.defaultcf.level0_slowdown_writes_trigger, + Some(1) + ); + assert_eq!( + cfg.rocksdb.defaultcf.soft_pending_compaction_bytes_limit, + Some(ReadableSize::gb(1)) + ); + } } diff --git a/tests/integrations/config/mod.rs b/tests/integrations/config/mod.rs index 08cf6572cdc..4872b7557b2 100644 --- a/tests/integrations/config/mod.rs +++ b/tests/integrations/config/mod.rs @@ -312,8 +312,8 @@ fn test_serde_custom_tikv_config() { max_bytes_for_level_base: ReadableSize::kb(12), target_file_size_base: ReadableSize::kb(123), level0_file_num_compaction_trigger: 123, - level0_slowdown_writes_trigger: 123, - level0_stop_writes_trigger: 123, + level0_slowdown_writes_trigger: Some(123), + level0_stop_writes_trigger: Some(123), max_compaction_bytes: ReadableSize::gb(1), compaction_pri: CompactionPriority::MinOverlappingRatio, dynamic_level_bytes: true, @@ -322,8 +322,8 @@ fn test_serde_custom_tikv_config() { compaction_style: DBCompactionStyle::Universal, disable_auto_compactions: true, disable_write_stall: true, - soft_pending_compaction_bytes_limit: ReadableSize::gb(12), - hard_pending_compaction_bytes_limit: ReadableSize::gb(12), + soft_pending_compaction_bytes_limit: Some(ReadableSize::gb(12)), + hard_pending_compaction_bytes_limit: Some(ReadableSize::gb(12)), force_consistency_checks: true, titan: titan_cf_config.clone(), prop_size_index_distance: 4000000, @@ -363,8 +363,8 @@ fn test_serde_custom_tikv_config() { max_bytes_for_level_base: ReadableSize::kb(12), target_file_size_base: ReadableSize::kb(123), level0_file_num_compaction_trigger: 123, - level0_slowdown_writes_trigger: 123, - level0_stop_writes_trigger: 123, + level0_slowdown_writes_trigger: Some(123), + level0_stop_writes_trigger: Some(123), max_compaction_bytes: ReadableSize::gb(1), compaction_pri: CompactionPriority::MinOverlappingRatio, dynamic_level_bytes: true, @@ -373,8 +373,8 @@ fn test_serde_custom_tikv_config() { compaction_style: DBCompactionStyle::Universal, disable_auto_compactions: true, disable_write_stall: true, - soft_pending_compaction_bytes_limit: ReadableSize::gb(12), - hard_pending_compaction_bytes_limit: ReadableSize::gb(12), + soft_pending_compaction_bytes_limit: Some(ReadableSize::gb(12)), + hard_pending_compaction_bytes_limit: Some(ReadableSize::gb(12)), force_consistency_checks: true, titan: TitanCfConfig { min_blob_size: ReadableSize(1024), // default value @@ -428,8 +428,8 @@ fn test_serde_custom_tikv_config() { max_bytes_for_level_base: ReadableSize::kb(12), target_file_size_base: ReadableSize::kb(123), level0_file_num_compaction_trigger: 123, - level0_slowdown_writes_trigger: 123, - level0_stop_writes_trigger: 123, + level0_slowdown_writes_trigger: Some(123), + level0_stop_writes_trigger: Some(123), max_compaction_bytes: ReadableSize::gb(1), compaction_pri: CompactionPriority::MinOverlappingRatio, dynamic_level_bytes: true, @@ -438,8 +438,8 @@ fn test_serde_custom_tikv_config() { compaction_style: DBCompactionStyle::Universal, disable_auto_compactions: true, disable_write_stall: true, - soft_pending_compaction_bytes_limit: ReadableSize::gb(12), - hard_pending_compaction_bytes_limit: ReadableSize::gb(12), + soft_pending_compaction_bytes_limit: Some(ReadableSize::gb(12)), + hard_pending_compaction_bytes_limit: Some(ReadableSize::gb(12)), force_consistency_checks: true, titan: TitanCfConfig { min_blob_size: ReadableSize(1024), // default value @@ -493,8 +493,8 @@ fn test_serde_custom_tikv_config() { max_bytes_for_level_base: ReadableSize::kb(12), target_file_size_base: ReadableSize::kb(123), level0_file_num_compaction_trigger: 123, - level0_slowdown_writes_trigger: 123, - level0_stop_writes_trigger: 123, + level0_slowdown_writes_trigger: Some(123), + level0_stop_writes_trigger: Some(123), max_compaction_bytes: ReadableSize::gb(1), compaction_pri: CompactionPriority::MinOverlappingRatio, dynamic_level_bytes: true, @@ -503,8 +503,8 @@ fn test_serde_custom_tikv_config() { compaction_style: DBCompactionStyle::Universal, disable_auto_compactions: true, disable_write_stall: true, - soft_pending_compaction_bytes_limit: ReadableSize::gb(12), - hard_pending_compaction_bytes_limit: ReadableSize::gb(12), + soft_pending_compaction_bytes_limit: Some(ReadableSize::gb(12)), + hard_pending_compaction_bytes_limit: Some(ReadableSize::gb(12)), force_consistency_checks: true, titan: TitanCfConfig { min_blob_size: ReadableSize(1024), // default value @@ -587,8 +587,8 @@ fn test_serde_custom_tikv_config() { max_bytes_for_level_base: ReadableSize::kb(12), target_file_size_base: ReadableSize::kb(123), level0_file_num_compaction_trigger: 123, - level0_slowdown_writes_trigger: 123, - level0_stop_writes_trigger: 123, + level0_slowdown_writes_trigger: Some(123), + level0_stop_writes_trigger: Some(123), max_compaction_bytes: ReadableSize::gb(1), compaction_pri: CompactionPriority::MinOverlappingRatio, dynamic_level_bytes: true, @@ -597,8 +597,8 @@ fn test_serde_custom_tikv_config() { compaction_style: DBCompactionStyle::Universal, disable_auto_compactions: true, disable_write_stall: true, - soft_pending_compaction_bytes_limit: ReadableSize::gb(12), - hard_pending_compaction_bytes_limit: ReadableSize::gb(12), + soft_pending_compaction_bytes_limit: Some(ReadableSize::gb(12)), + hard_pending_compaction_bytes_limit: Some(ReadableSize::gb(12)), force_consistency_checks: true, titan: titan_cf_config, prop_size_index_distance: 4000000,