diff --git a/Cargo.toml b/Cargo.toml index 90627cdad..6db3cb008 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -193,10 +193,6 @@ path = "src/bin/importer_offline.rs" name = "historic_events_processor" path = "src/bin/historic_events_processor.rs" -[[bin]] -name = "rocks_migration" -path = "src/bin/rocks_migration.rs" - # ------------------------------------------------------------------------------ # Features # ------------------------------------------------------------------------------ diff --git a/benchmark_results/run_20241203_200314/config_01_minimal.rs b/benchmark_results/run_20241203_200314/config_01_minimal.rs deleted file mode 100644 index d3a75f278..000000000 --- a/benchmark_results/run_20241203_200314/config_01_minimal.rs +++ /dev/null @@ -1,63 +0,0 @@ -use rocksdb::BlockBasedOptions; -use rocksdb::Cache; -use rocksdb::Options; - -pub enum CacheSetting { - /// Enabled cache with the given size in bytes - Enabled(usize), - Disabled, -} - -#[derive(Debug, Clone, Copy)] -pub enum DbConfig { - OptimizedPointLookUp, - Default, -} - -impl Default for DbConfig { - fn default() -> Self { - Self::Default - } -} - -impl DbConfig { - pub fn to_options(self, cache_setting: CacheSetting, _prefix_len: Option, _key_len: usize) -> Options { - let mut opts = Options::default(); - let mut block_based_options = BlockBasedOptions::default(); - - opts.create_if_missing(true); - opts.create_missing_column_families(true); - opts.increase_parallelism(16); - block_based_options.set_pin_l0_filter_and_index_blocks_in_cache(true); - block_based_options.set_cache_index_and_filter_blocks(true); - block_based_options.set_ribbon_filter(15.5); - - // NOTE: As per the rocks db wiki: "The overhead of statistics is usually small but non-negligible. We usually observe an overhead of 5%-10%." - #[cfg(feature = "metrics")] - { - opts.enable_statistics(); - opts.set_statistics_level(rocksdb::statistics::StatsLevel::ExceptTimeForMutex); - } - - if let CacheSetting::Enabled(cache_size) = cache_setting { - let cache = Cache::new_lru_cache(cache_size); - block_based_options.set_block_cache(&cache); - block_based_options.set_cache_index_and_filter_blocks(true); - } - - match self { - DbConfig::OptimizedPointLookUp => { - opts.set_compression_type(rocksdb::DBCompressionType::None); - } - DbConfig::Default => { - opts.set_compression_type(rocksdb::DBCompressionType::Lz4); - opts.set_bottommost_compression_type(rocksdb::DBCompressionType::Zstd); - opts.set_bottommost_compression_options(-14, 32767, 0, 16 * 1024, true); // mostry defaults except max_dict_bytes - opts.set_bottommost_zstd_max_train_bytes(1600 * 1024, true); - } - } - - opts.set_block_based_table_factory(&block_based_options); - opts - } -} diff --git a/benchmark_results/run_20241203_200314/results.json b/benchmark_results/run_20241203_200314/results.json deleted file mode 100644 index 7aaadb3f3..000000000 --- a/benchmark_results/run_20241203_200314/results.json +++ /dev/null @@ -1,21 +0,0 @@ -{ - "run_id": "bench-1551571515", - "rps_summary": { - "max": 2188.0, - "min": 141.0, - "average": 1277.9217970049917, - "std_dev": 148.8649195310536 - }, - "tps_summary": { - "max": 1709.0, - "min": 155.0, - "average": 1276.4040066777964, - "std_dev": 148.1488120150672 - }, - "revert_summary": { - "max": 0.0, - "min": 0.0, - "average": 0.0, - "std_dev": 0.0 - } -} \ No newline at end of file diff --git a/benchmark_results/run_20241203_211023/config_02_OptimizeForPointLookup.rs b/benchmark_results/run_20241203_211023/config_02_OptimizeForPointLookup.rs deleted file mode 100644 index 7b5cc6c9e..000000000 --- a/benchmark_results/run_20241203_211023/config_02_OptimizeForPointLookup.rs +++ /dev/null @@ -1,68 +0,0 @@ -use rocksdb::BlockBasedOptions; -use rocksdb::Cache; -use rocksdb::Options; - -pub enum CacheSetting { - /// Enabled cache with the given size in bytes - Enabled(usize), - Disabled, -} - -#[derive(Debug, Clone, Copy)] -pub enum DbConfig { - OptimizedPointLookUp, - Default, -} - -impl Default for DbConfig { - fn default() -> Self { - Self::Default - } -} - -impl DbConfig { - pub fn to_options(self, cache_setting: CacheSetting, _prefix_len: Option, _key_len: usize) -> Options { - let mut opts = Options::default(); - let mut block_based_options = BlockBasedOptions::default(); - - opts.create_if_missing(true); - opts.create_missing_column_families(true); - opts.increase_parallelism(16); - block_based_options.set_pin_l0_filter_and_index_blocks_in_cache(true); - block_based_options.set_cache_index_and_filter_blocks(true); - block_based_options.set_bloom_filter(15.5, true); - - // NOTE: As per the rocks db wiki: "The overhead of statistics is usually small but non-negligible. We usually observe an overhead of 5%-10%." - #[cfg(feature = "metrics")] - { - opts.enable_statistics(); - opts.set_statistics_level(rocksdb::statistics::StatsLevel::ExceptTimeForMutex); - } - - if let CacheSetting::Enabled(cache_size) = cache_setting { - let cache = Cache::new_lru_cache(cache_size); - block_based_options.set_block_cache(&cache); - } - - match self { - DbConfig::OptimizedPointLookUp => { - block_based_options.set_data_block_hash_ratio(0.5); - block_based_options.set_data_block_index_type(rocksdb::DataBlockIndexType::BinaryAndHash); - opts.set_memtable_whole_key_filtering(true); - opts.set_memtable_prefix_bloom_ratio(0.02); - opts.set_compression_type(rocksdb::DBCompressionType::None); - } - DbConfig::Default => { - opts.set_compression_type(rocksdb::DBCompressionType::Lz4); - opts.set_bottommost_compression_type(rocksdb::DBCompressionType::Zstd); - opts.set_bottommost_compression_options(-14, 32767, 0, 16 * 1024, true); // mostly defaults except max_dict_bytes - opts.set_bottommost_zstd_max_train_bytes(1600 * 1024, true); - } - } - - - - opts.set_block_based_table_factory(&block_based_options); - opts - } -} diff --git a/benchmark_results/run_20241203_211023/results.json b/benchmark_results/run_20241203_211023/results.json deleted file mode 100644 index 7420cffa8..000000000 --- a/benchmark_results/run_20241203_211023/results.json +++ /dev/null @@ -1,21 +0,0 @@ -{ - "run_id": "bench-4141258073", - "rps_summary": { - "max": 2110.0, - "min": 229.0, - "average": 1287.1597337770384, - "std_dev": 143.14684561751704 - }, - "tps_summary": { - "max": 1655.0, - "min": 19.0, - "average": 1284.5116666666668, - "std_dev": 147.6963772876263 - }, - "revert_summary": { - "max": 0.0, - "min": 0.0, - "average": 0.0, - "std_dev": 0.0 - } -} \ No newline at end of file diff --git a/benchmark_results/run_20241203_221827/config_03_PrefixExtractor.rs b/benchmark_results/run_20241203_221827/config_03_PrefixExtractor.rs deleted file mode 100644 index 40a3204c9..000000000 --- a/benchmark_results/run_20241203_221827/config_03_PrefixExtractor.rs +++ /dev/null @@ -1,72 +0,0 @@ -use rocksdb::BlockBasedOptions; -use rocksdb::Cache; -use rocksdb::Options; - -pub enum CacheSetting { - /// Enabled cache with the given size in bytes - Enabled(usize), - Disabled, -} - -#[derive(Debug, Clone, Copy)] -pub enum DbConfig { - OptimizedPointLookUp, - Default, -} - -impl Default for DbConfig { - fn default() -> Self { - Self::Default - } -} - -impl DbConfig { - pub fn to_options(self, cache_setting: CacheSetting, prefix_len: Option, _key_len: usize) -> Options { - let mut opts = Options::default(); - let mut block_based_options = BlockBasedOptions::default(); - - opts.create_if_missing(true); - opts.create_missing_column_families(true); - opts.increase_parallelism(16); - - block_based_options.set_pin_l0_filter_and_index_blocks_in_cache(true); - block_based_options.set_cache_index_and_filter_blocks(true); - block_based_options.set_bloom_filter(15.5, true); - - // NOTE: As per the rocks db wiki: "The overhead of statistics is usually small but non-negligible. We usually observe an overhead of 5%-10%." - #[cfg(feature = "metrics")] - { - opts.enable_statistics(); - opts.set_statistics_level(rocksdb::statistics::StatsLevel::ExceptTimeForMutex); - } - - if let Some(prefix_len) = prefix_len { - let transform = rocksdb::SliceTransform::create_fixed_prefix(prefix_len); - opts.set_memtable_prefix_bloom_ratio(0.02); - opts.set_prefix_extractor(transform); - } - - if let CacheSetting::Enabled(cache_size) = cache_setting { - let cache = Cache::new_lru_cache(cache_size); - block_based_options.set_block_cache(&cache); - } - - match self { - DbConfig::OptimizedPointLookUp => { - block_based_options.set_data_block_hash_ratio(0.5); - block_based_options.set_data_block_index_type(rocksdb::DataBlockIndexType::BinaryAndHash); - opts.set_memtable_whole_key_filtering(true); - opts.set_compression_type(rocksdb::DBCompressionType::None); - } - DbConfig::Default => { - opts.set_compression_type(rocksdb::DBCompressionType::Lz4); - opts.set_bottommost_compression_type(rocksdb::DBCompressionType::Zstd); - opts.set_bottommost_compression_options(-14, 32767, 0, 16 * 1024, true); // mostly defaults except max_dict_bytes - opts.set_bottommost_zstd_max_train_bytes(1600 * 1024, true); - } - } - - opts.set_block_based_table_factory(&block_based_options); - opts - } -} diff --git a/benchmark_results/run_20241203_221827/results.json b/benchmark_results/run_20241203_221827/results.json deleted file mode 100644 index 4f36a090f..000000000 --- a/benchmark_results/run_20241203_221827/results.json +++ /dev/null @@ -1,21 +0,0 @@ -{ - "run_id": "bench-2127247197", - "rps_summary": { - "max": 2132.0, - "min": 189.0, - "average": 1287.7853577371047, - "std_dev": 139.48197070467822 - }, - "tps_summary": { - "max": 1646.0, - "min": 151.0, - "average": 1286.5375626043406, - "std_dev": 135.70412985425867 - }, - "revert_summary": { - "max": 0.0, - "min": 0.0, - "average": 0.0, - "std_dev": 0.0 - } -} \ No newline at end of file diff --git a/benchmark_results/run_20241203_232619/config_04_RowCache.rs b/benchmark_results/run_20241203_232619/config_04_RowCache.rs deleted file mode 100644 index d22f43061..000000000 --- a/benchmark_results/run_20241203_232619/config_04_RowCache.rs +++ /dev/null @@ -1,76 +0,0 @@ -use rocksdb::BlockBasedOptions; -use rocksdb::Cache; -use rocksdb::Options; - -pub enum CacheSetting { - /// Enabled cache with the given size in bytes - Enabled(usize), - Disabled, -} - -#[derive(Debug, Clone, Copy)] -pub enum DbConfig { - OptimizedPointLookUp, - Default, -} - -impl Default for DbConfig { - fn default() -> Self { - Self::Default - } -} - -impl DbConfig { - pub fn to_options(self, cache_setting: CacheSetting, prefix_len: Option, _key_len: usize) -> Options { - let mut opts = Options::default(); - let mut block_based_options = BlockBasedOptions::default(); - - opts.create_if_missing(true); - opts.create_missing_column_families(true); - opts.increase_parallelism(16); - - block_based_options.set_pin_l0_filter_and_index_blocks_in_cache(true); - block_based_options.set_cache_index_and_filter_blocks(true); - block_based_options.set_bloom_filter(15.5, true); - - // NOTE: As per the rocks db wiki: "The overhead of statistics is usually small but non-negligible. We usually observe an overhead of 5%-10%." - #[cfg(feature = "metrics")] - { - opts.enable_statistics(); - opts.set_statistics_level(rocksdb::statistics::StatsLevel::ExceptTimeForMutex); - } - - if let Some(prefix_len) = prefix_len { - let transform = rocksdb::SliceTransform::create_fixed_prefix(prefix_len); - opts.set_memtable_prefix_bloom_ratio(0.02); - opts.set_prefix_extractor(transform); - } - - if let CacheSetting::Enabled(cache_size) = cache_setting { - let block_cache = Cache::new_lru_cache(cache_size/2); - let row_cache = Cache::new_lru_cache(cache_size/2); - - opts.set_row_cache(&row_cache); - block_based_options.set_block_cache(&block_cache); - } - - match self { - DbConfig::OptimizedPointLookUp => { - block_based_options.set_data_block_hash_ratio(0.5); - block_based_options.set_data_block_index_type(rocksdb::DataBlockIndexType::BinaryAndHash); - opts.set_memtable_whole_key_filtering(true); - opts.set_compression_type(rocksdb::DBCompressionType::None); - } - DbConfig::Default => { - opts.set_compression_type(rocksdb::DBCompressionType::Lz4); - opts.set_bottommost_compression_type(rocksdb::DBCompressionType::Zstd); - opts.set_bottommost_compression_options(-14, 32767, 0, 16 * 1024, true); // mostly defaults except max_dict_bytes - opts.set_bottommost_zstd_max_train_bytes(1600 * 1024, true); - } - } - - opts.set_block_based_table_factory(&block_based_options); - - opts - } -} diff --git a/benchmark_results/run_20241203_232619/results.json b/benchmark_results/run_20241203_232619/results.json deleted file mode 100644 index 986f66c1c..000000000 --- a/benchmark_results/run_20241203_232619/results.json +++ /dev/null @@ -1,21 +0,0 @@ -{ - "run_id": "bench-3409563203", - "rps_summary": { - "max": 2169.0, - "min": 93.0, - "average": 1288.467554076539, - "std_dev": 143.4080643036806 - }, - "tps_summary": { - "max": 1676.0, - "min": 61.0, - "average": 1286.2116666666666, - "std_dev": 143.78252164486327 - }, - "revert_summary": { - "max": 0.0, - "min": 0.0, - "average": 0.0, - "std_dev": 0.0 - } -} \ No newline at end of file diff --git a/benchmark_results/run_20241204_003431/config_05_HashSearchIndexType.rs b/benchmark_results/run_20241204_003431/config_05_HashSearchIndexType.rs deleted file mode 100644 index 73cb195ac..000000000 --- a/benchmark_results/run_20241204_003431/config_05_HashSearchIndexType.rs +++ /dev/null @@ -1,77 +0,0 @@ -use rocksdb::BlockBasedOptions; -use rocksdb::Cache; -use rocksdb::Options; - -pub enum CacheSetting { - /// Enabled cache with the given size in bytes - Enabled(usize), - Disabled, -} - -#[derive(Debug, Clone, Copy)] -pub enum DbConfig { - OptimizedPointLookUp, - Default, -} - -impl Default for DbConfig { - fn default() -> Self { - Self::Default - } -} - -impl DbConfig { - pub fn to_options(self, cache_setting: CacheSetting, prefix_len: Option, _key_len: usize) -> Options { - let mut opts = Options::default(); - let mut block_based_options = BlockBasedOptions::default(); - - opts.create_if_missing(true); - opts.create_missing_column_families(true); - opts.increase_parallelism(16); - - block_based_options.set_pin_l0_filter_and_index_blocks_in_cache(true); - block_based_options.set_cache_index_and_filter_blocks(true); - block_based_options.set_bloom_filter(15.5, true); - - // NOTE: As per the rocks db wiki: "The overhead of statistics is usually small but non-negligible. We usually observe an overhead of 5%-10%." - #[cfg(feature = "metrics")] - { - opts.enable_statistics(); - opts.set_statistics_level(rocksdb::statistics::StatsLevel::ExceptTimeForMutex); - } - - if let Some(prefix_len) = prefix_len { - let transform = rocksdb::SliceTransform::create_fixed_prefix(prefix_len); - block_based_options.set_index_type(rocksdb::BlockBasedIndexType::HashSearch); - opts.set_memtable_prefix_bloom_ratio(0.02); - opts.set_prefix_extractor(transform); - } - - if let CacheSetting::Enabled(cache_size) = cache_setting { - let block_cache = Cache::new_lru_cache(cache_size/2); - let row_cache = Cache::new_lru_cache(cache_size/2); - - opts.set_row_cache(&row_cache); - block_based_options.set_block_cache(&block_cache); - } - - match self { - DbConfig::OptimizedPointLookUp => { - block_based_options.set_data_block_hash_ratio(0.5); - block_based_options.set_data_block_index_type(rocksdb::DataBlockIndexType::BinaryAndHash); - opts.set_memtable_whole_key_filtering(true); - opts.set_compression_type(rocksdb::DBCompressionType::None); - } - DbConfig::Default => { - opts.set_compression_type(rocksdb::DBCompressionType::Lz4); - opts.set_bottommost_compression_type(rocksdb::DBCompressionType::Zstd); - opts.set_bottommost_compression_options(-14, 32767, 0, 16 * 1024, true); // mostly defaults except max_dict_bytes - opts.set_bottommost_zstd_max_train_bytes(1600 * 1024, true); - } - } - - opts.set_block_based_table_factory(&block_based_options); - - opts - } -} diff --git a/benchmark_results/run_20241204_003431/results.json b/benchmark_results/run_20241204_003431/results.json deleted file mode 100644 index 5a41b7707..000000000 --- a/benchmark_results/run_20241204_003431/results.json +++ /dev/null @@ -1,21 +0,0 @@ -{ - "run_id": "bench-2237706652", - "rps_summary": { - "max": 2148.0, - "min": 218.0, - "average": 1291.8785357737104, - "std_dev": 146.64448806116528 - }, - "tps_summary": { - "max": 1695.0, - "min": 8.0, - "average": 1288.605, - "std_dev": 151.43789367812363 - }, - "revert_summary": { - "max": 0.0, - "min": 0.0, - "average": 0.0, - "std_dev": 0.0 - } -} \ No newline at end of file diff --git a/benchmark_results/run_20241204_014219/config_06_DirectIO.rs b/benchmark_results/run_20241204_014219/config_06_DirectIO.rs deleted file mode 100644 index e130a7129..000000000 --- a/benchmark_results/run_20241204_014219/config_06_DirectIO.rs +++ /dev/null @@ -1,80 +0,0 @@ -use rocksdb::BlockBasedOptions; -use rocksdb::Cache; -use rocksdb::Options; - -pub enum CacheSetting { - /// Enabled cache with the given size in bytes - Enabled(usize), - Disabled, -} - -#[derive(Debug, Clone, Copy)] -pub enum DbConfig { - OptimizedPointLookUp, - Default, -} - -impl Default for DbConfig { - fn default() -> Self { - Self::Default - } -} - -impl DbConfig { - pub fn to_options(self, cache_setting: CacheSetting, prefix_len: Option, _key_len: usize) -> Options { - let mut opts = Options::default(); - let mut block_based_options = BlockBasedOptions::default(); - - opts.create_if_missing(true); - opts.create_missing_column_families(true); - opts.increase_parallelism(16); - // add an assertion so that the ulimit -n is at least double this. - // opts.set_max_open_files(40960); - - block_based_options.set_pin_l0_filter_and_index_blocks_in_cache(true); - block_based_options.set_cache_index_and_filter_blocks(true); - block_based_options.set_bloom_filter(15.5, true); - - // NOTE: As per the rocks db wiki: "The overhead of statistics is usually small but non-negligible. We usually observe an overhead of 5%-10%." - #[cfg(feature = "metrics")] - { - opts.enable_statistics(); - opts.set_statistics_level(rocksdb::statistics::StatsLevel::ExceptTimeForMutex); - } - - if let Some(prefix_len) = prefix_len { - let transform = rocksdb::SliceTransform::create_fixed_prefix(prefix_len); - block_based_options.set_index_type(rocksdb::BlockBasedIndexType::HashSearch); - opts.set_memtable_prefix_bloom_ratio(0.02); - opts.set_prefix_extractor(transform); - } - - if let CacheSetting::Enabled(cache_size) = cache_setting { - let block_cache = Cache::new_lru_cache(cache_size/2); - let row_cache = Cache::new_lru_cache(cache_size/2); - - opts.set_row_cache(&row_cache); - block_based_options.set_block_cache(&block_cache); - } - - match self { - DbConfig::OptimizedPointLookUp => { - block_based_options.set_data_block_hash_ratio(0.5); - block_based_options.set_data_block_index_type(rocksdb::DataBlockIndexType::BinaryAndHash); - opts.set_use_direct_reads(true); - opts.set_memtable_whole_key_filtering(true); - opts.set_compression_type(rocksdb::DBCompressionType::None); - } - DbConfig::Default => { - opts.set_compression_type(rocksdb::DBCompressionType::Lz4); - opts.set_bottommost_compression_type(rocksdb::DBCompressionType::Zstd); - opts.set_bottommost_compression_options(-14, 32767, 0, 16 * 1024, true); // mostly defaults except max_dict_bytes - opts.set_bottommost_zstd_max_train_bytes(1600 * 1024, true); - } - } - - opts.set_block_based_table_factory(&block_based_options); - - opts - } -} diff --git a/benchmark_results/run_20241204_014219/results.json b/benchmark_results/run_20241204_014219/results.json deleted file mode 100644 index b114afca5..000000000 --- a/benchmark_results/run_20241204_014219/results.json +++ /dev/null @@ -1,21 +0,0 @@ -{ - "run_id": "bench-3179892338", - "rps_summary": { - "max": 2131.0, - "min": 86.0, - "average": 1300.16306156406, - "std_dev": 150.61002976175408 - }, - "tps_summary": { - "max": 1718.0, - "min": 153.0, - "average": 1298.8280467445743, - "std_dev": 145.71086063228603 - }, - "revert_summary": { - "max": 0.0, - "min": 0.0, - "average": 0.0, - "std_dev": 0.0 - } -} \ No newline at end of file diff --git a/benchmark_results/run_20241204_025305/config_07_HashSkipList.rs b/benchmark_results/run_20241204_025305/config_07_HashSkipList.rs deleted file mode 100644 index cbe7e107e..000000000 --- a/benchmark_results/run_20241204_025305/config_07_HashSkipList.rs +++ /dev/null @@ -1,81 +0,0 @@ -use rocksdb::BlockBasedOptions; -use rocksdb::Cache; -use rocksdb::MemtableFactory; -use rocksdb::Options; - -pub enum CacheSetting { - /// Enabled cache with the given size in bytes - Enabled(usize), - Disabled, -} - -#[derive(Debug, Clone, Copy)] -pub enum DbConfig { - OptimizedPointLookUp, - Default, -} - -impl Default for DbConfig { - fn default() -> Self { - Self::Default - } -} - -impl DbConfig { - pub fn to_options(self, cache_setting: CacheSetting, prefix_len: Option, _key_len: usize) -> Options { - let mut opts = Options::default(); - let mut block_based_options = BlockBasedOptions::default(); - - opts.create_if_missing(true); - opts.create_missing_column_families(true); - opts.increase_parallelism(16); - block_based_options.set_pin_l0_filter_and_index_blocks_in_cache(true); - block_based_options.set_cache_index_and_filter_blocks(true); - block_based_options.set_bloom_filter(15.5, true); - - opts.set_allow_concurrent_memtable_write(false); - - // NOTE: As per the rocks db wiki: "The overhead of statistics is usually small but non-negligible. We usually observe an overhead of 5%-10%." - #[cfg(feature = "metrics")] - { - opts.enable_statistics(); - opts.set_statistics_level(rocksdb::statistics::StatsLevel::ExceptTimeForMutex); - } - - if let Some(prefix_len) = prefix_len { - let transform = rocksdb::SliceTransform::create_fixed_prefix(prefix_len); - block_based_options.set_index_type(rocksdb::BlockBasedIndexType::HashSearch); - opts.set_memtable_whole_key_filtering(true); - opts.set_memtable_factory(MemtableFactory::HashSkipList { bucket_count: 10000, height: 4, branching_factor: 4 }); - opts.set_memtable_prefix_bloom_ratio(0.2); - opts.set_prefix_extractor(transform); - } - - if let CacheSetting::Enabled(cache_size) = cache_setting { - let block_cache = Cache::new_lru_cache(cache_size/2); - let row_cache = Cache::new_lru_cache(cache_size/2); - - opts.set_row_cache(&row_cache); - block_based_options.set_block_cache(&block_cache); - } - - match self { - DbConfig::OptimizedPointLookUp => { - block_based_options.set_data_block_hash_ratio(0.5); - block_based_options.set_data_block_index_type(rocksdb::DataBlockIndexType::BinaryAndHash); - opts.set_use_direct_reads(true); - opts.set_compression_type(rocksdb::DBCompressionType::None); - } - DbConfig::Default => { - opts.set_compression_type(rocksdb::DBCompressionType::Lz4); - opts.set_bottommost_compression_type(rocksdb::DBCompressionType::Zstd); - opts.set_bottommost_compression_options(-14, 32767, 0, 16 * 1024, true); // mostly defaults except max_dict_bytes - opts.set_bottommost_zstd_max_train_bytes(1600 * 1024, true); - } - } - - opts.set_block_based_table_factory(&block_based_options); - - opts - } -} diff --git a/benchmark_results/run_20241204_025305/results.json b/benchmark_results/run_20241204_025305/results.json deleted file mode 100644 index 079a67b70..000000000 --- a/benchmark_results/run_20241204_025305/results.json +++ /dev/null @@ -1,21 +0,0 @@ -{ - "run_id": "bench-1735129793", - "rps_summary": { - "max": 2147.0, - "min": 219.0, - "average": 1285.1031613976706, - "std_dev": 150.53223160529032 - }, - "tps_summary": { - "max": 1716.0, - "min": 176.0, - "average": 1284.0367278797996, - "std_dev": 147.075504395871 - }, - "revert_summary": { - "max": 0.0, - "min": 0.0, - "average": 0.0, - "std_dev": 0.0 - } -} \ No newline at end of file diff --git a/benchmark_results/run_20241204_112916/config_08_PlainTable.rs b/benchmark_results/run_20241204_112916/config_08_PlainTable.rs deleted file mode 100644 index 4d67d34c9..000000000 --- a/benchmark_results/run_20241204_112916/config_08_PlainTable.rs +++ /dev/null @@ -1,94 +0,0 @@ -use rocksdb::BlockBasedOptions; -use rocksdb::Cache; -use rocksdb::Options; -use rocksdb::PlainTableFactoryOptions; - -pub enum CacheSetting { - /// Enabled cache with the given size in bytes - Enabled(usize), - Disabled, -} - -#[derive(Debug, Clone, Copy)] -pub enum DbConfig { - OptimizedPointLookUp, - Default, -} - -impl Default for DbConfig { - fn default() -> Self { - Self::Default - } -} - -impl DbConfig { - pub fn to_options(self, cache_setting: CacheSetting, prefix_len: Option, key_len: usize) -> Options { - let mut opts = Options::default(); - let mut block_based_options = BlockBasedOptions::default(); - - opts.create_if_missing(true); - opts.create_missing_column_families(true); - opts.increase_parallelism(16); - // add an assertion so that the ulimit -n is at least double this. - // opts.set_max_open_files(40960); - - block_based_options.set_pin_l0_filter_and_index_blocks_in_cache(true); - block_based_options.set_cache_index_and_filter_blocks(true); - block_based_options.set_bloom_filter(15.5, true); - opts.set_allow_concurrent_memtable_write(false); - - // NOTE: As per the rocks db wiki: "The overhead of statistics is usually small but non-negligible. We usually observe an overhead of 5%-10%." - #[cfg(feature = "metrics")] - { - opts.enable_statistics(); - opts.set_statistics_level(rocksdb::statistics::StatsLevel::ExceptTimeForMutex); - } - - if let Some(prefix_len) = prefix_len { - let transform = rocksdb::SliceTransform::create_fixed_prefix(prefix_len); - block_based_options.set_index_type(rocksdb::BlockBasedIndexType::HashSearch); - opts.set_memtable_whole_key_filtering(true); - opts.set_memtable_prefix_bloom_ratio(0.2); - opts.set_prefix_extractor(transform); - } - - if let CacheSetting::Enabled(cache_size) = cache_setting { - let block_cache = Cache::new_lru_cache(cache_size/2); - let row_cache = Cache::new_lru_cache(cache_size/2); - - opts.set_row_cache(&row_cache); - block_based_options.set_block_cache(&block_cache); - } - - match self { - DbConfig::OptimizedPointLookUp => { - let plain = PlainTableFactoryOptions { - user_key_length: key_len as u32, - bloom_bits_per_key: 15, - hash_table_ratio: 0.75, - index_sparseness: 16, - huge_page_tlb_size: 0, - encoding_type: rocksdb::KeyEncodingType::Plain, - full_scan_mode: false, - store_index_in_file: true - }; - - opts.set_use_direct_reads(true); - opts.set_memtable_whole_key_filtering(true); - - opts.set_compression_type(rocksdb::DBCompressionType::None); - opts.set_plain_table_factory(&plain); - } - DbConfig::Default => { - opts.set_compression_type(rocksdb::DBCompressionType::Lz4); - opts.set_bottommost_compression_type(rocksdb::DBCompressionType::Zstd); - opts.set_bottommost_compression_options(-14, 32767, 0, 16 * 1024, true); // mostly defaults except max_dict_bytes - opts.set_bottommost_zstd_max_train_bytes(1600 * 1024, true); - } - } - - opts.set_block_based_table_factory(&block_based_options); - - opts - } -} diff --git a/benchmark_results/run_20241204_112916/results.json b/benchmark_results/run_20241204_112916/results.json deleted file mode 100644 index e434d1678..000000000 --- a/benchmark_results/run_20241204_112916/results.json +++ /dev/null @@ -1,21 +0,0 @@ -{ - "run_id": "bench-311329613", - "rps_summary": { - "max": 2154.0, - "min": 239.0, - "average": 1302.2113144758735, - "std_dev": 149.43116859674558 - }, - "tps_summary": { - "max": 1689.0, - "min": 73.0, - "average": 1300.0716666666667, - "std_dev": 151.4024874208553 - }, - "revert_summary": { - "max": 0.0, - "min": 0.0, - "average": 0.0, - "std_dev": 0.0 - } -} \ No newline at end of file diff --git a/benchmark_results/run_20241204_123724/config_09_small_hash_ratio.rs b/benchmark_results/run_20241204_123724/config_09_small_hash_ratio.rs deleted file mode 100644 index 6c5e04b66..000000000 --- a/benchmark_results/run_20241204_123724/config_09_small_hash_ratio.rs +++ /dev/null @@ -1,80 +0,0 @@ -use rocksdb::BlockBasedOptions; -use rocksdb::Cache; -use rocksdb::Options; - -pub enum CacheSetting { - /// Enabled cache with the given size in bytes - Enabled(usize), - Disabled, -} - -#[derive(Debug, Clone, Copy)] -pub enum DbConfig { - OptimizedPointLookUp, - Default, -} - -impl Default for DbConfig { - fn default() -> Self { - Self::Default - } -} - -impl DbConfig { - pub fn to_options(self, cache_setting: CacheSetting, prefix_len: Option, _key_len: usize) -> Options { - let mut opts = Options::default(); - let mut block_based_options = BlockBasedOptions::default(); - - opts.create_if_missing(true); - opts.create_missing_column_families(true); - opts.increase_parallelism(16); - // add an assertion so that the ulimit -n is at least double this. - // opts.set_max_open_files(40960); - - block_based_options.set_pin_l0_filter_and_index_blocks_in_cache(true); - block_based_options.set_cache_index_and_filter_blocks(true); - block_based_options.set_bloom_filter(15.5, true); - - // NOTE: As per the rocks db wiki: "The overhead of statistics is usually small but non-negligible. We usually observe an overhead of 5%-10%." - #[cfg(feature = "metrics")] - { - opts.enable_statistics(); - opts.set_statistics_level(rocksdb::statistics::StatsLevel::ExceptTimeForMutex); - } - - if let Some(prefix_len) = prefix_len { - let transform = rocksdb::SliceTransform::create_fixed_prefix(prefix_len); - block_based_options.set_index_type(rocksdb::BlockBasedIndexType::HashSearch); - opts.set_memtable_prefix_bloom_ratio(0.02); - opts.set_prefix_extractor(transform); - } - - if let CacheSetting::Enabled(cache_size) = cache_setting { - let block_cache = Cache::new_lru_cache(cache_size/2); - let row_cache = Cache::new_lru_cache(cache_size/2); - - opts.set_row_cache(&row_cache); - block_based_options.set_block_cache(&block_cache); - } - - match self { - DbConfig::OptimizedPointLookUp => { - block_based_options.set_data_block_hash_ratio(0.1); - block_based_options.set_data_block_index_type(rocksdb::DataBlockIndexType::BinaryAndHash); - opts.set_use_direct_reads(true); - opts.set_memtable_whole_key_filtering(true); - opts.set_compression_type(rocksdb::DBCompressionType::None); - } - DbConfig::Default => { - opts.set_compression_type(rocksdb::DBCompressionType::Lz4); - opts.set_bottommost_compression_type(rocksdb::DBCompressionType::Zstd); - opts.set_bottommost_compression_options(-14, 32767, 0, 16 * 1024, true); // mostly defaults except max_dict_bytes - opts.set_bottommost_zstd_max_train_bytes(1600 * 1024, true); - } - } - - opts.set_block_based_table_factory(&block_based_options); - - opts - } -} diff --git a/benchmark_results/run_20241204_123724/results.json b/benchmark_results/run_20241204_123724/results.json deleted file mode 100644 index 1bcb7223f..000000000 --- a/benchmark_results/run_20241204_123724/results.json +++ /dev/null @@ -1,21 +0,0 @@ -{ - "run_id": "bench-3737871508", - "rps_summary": { - "max": 2149.0, - "min": 230.0, - "average": 1317.622296173045, - "std_dev": 140.41940542420053 - }, - "tps_summary": { - "max": 1713.0, - "min": 79.0, - "average": 1315.5766666666666, - "std_dev": 142.01472032465122 - }, - "revert_summary": { - "max": 0.0, - "min": 0.0, - "average": 0.0, - "std_dev": 0.0 - } -} \ No newline at end of file diff --git a/benchmark_results/run_20241204_134505/config_10_large_hash_ratio.rs b/benchmark_results/run_20241204_134505/config_10_large_hash_ratio.rs deleted file mode 100644 index f424ac7bc..000000000 --- a/benchmark_results/run_20241204_134505/config_10_large_hash_ratio.rs +++ /dev/null @@ -1,80 +0,0 @@ -use rocksdb::BlockBasedOptions; -use rocksdb::Cache; -use rocksdb::Options; - -pub enum CacheSetting { - /// Enabled cache with the given size in bytes - Enabled(usize), - Disabled, -} - -#[derive(Debug, Clone, Copy)] -pub enum DbConfig { - OptimizedPointLookUp, - Default, -} - -impl Default for DbConfig { - fn default() -> Self { - Self::Default - } -} - -impl DbConfig { - pub fn to_options(self, cache_setting: CacheSetting, prefix_len: Option, _key_len: usize) -> Options { - let mut opts = Options::default(); - let mut block_based_options = BlockBasedOptions::default(); - - opts.create_if_missing(true); - opts.create_missing_column_families(true); - opts.increase_parallelism(16); - // add an assertion so that the ulimit -n is at least double this. - // opts.set_max_open_files(40960); - - block_based_options.set_pin_l0_filter_and_index_blocks_in_cache(true); - block_based_options.set_cache_index_and_filter_blocks(true); - block_based_options.set_bloom_filter(15.5, true); - - // NOTE: As per the rocks db wiki: "The overhead of statistics is usually small but non-negligible. We usually observe an overhead of 5%-10%." - #[cfg(feature = "metrics")] - { - opts.enable_statistics(); - opts.set_statistics_level(rocksdb::statistics::StatsLevel::ExceptTimeForMutex); - } - - if let Some(prefix_len) = prefix_len { - let transform = rocksdb::SliceTransform::create_fixed_prefix(prefix_len); - block_based_options.set_index_type(rocksdb::BlockBasedIndexType::HashSearch); - opts.set_memtable_prefix_bloom_ratio(0.02); - opts.set_prefix_extractor(transform); - } - - if let CacheSetting::Enabled(cache_size) = cache_setting { - let block_cache = Cache::new_lru_cache(cache_size/2); - let row_cache = Cache::new_lru_cache(cache_size/2); - - opts.set_row_cache(&row_cache); - block_based_options.set_block_cache(&block_cache); - } - - match self { - DbConfig::OptimizedPointLookUp => { - block_based_options.set_data_block_hash_ratio(0.75); - block_based_options.set_data_block_index_type(rocksdb::DataBlockIndexType::BinaryAndHash); - opts.set_use_direct_reads(true); - opts.set_memtable_whole_key_filtering(true); - opts.set_compression_type(rocksdb::DBCompressionType::None); - } - DbConfig::Default => { - opts.set_compression_type(rocksdb::DBCompressionType::Lz4); - opts.set_bottommost_compression_type(rocksdb::DBCompressionType::Zstd); - opts.set_bottommost_compression_options(-14, 32767, 0, 16 * 1024, true); // mostly defaults except max_dict_bytes - opts.set_bottommost_zstd_max_train_bytes(1600 * 1024, true); - } - } - - opts.set_block_based_table_factory(&block_based_options); - - opts - } -} diff --git a/benchmark_results/run_20241204_134505/results.json b/benchmark_results/run_20241204_134505/results.json deleted file mode 100644 index 8cb16e9de..000000000 --- a/benchmark_results/run_20241204_134505/results.json +++ /dev/null @@ -1,21 +0,0 @@ -{ - "run_id": "bench-83481422", - "rps_summary": { - "max": 2419.0, - "min": 211.0, - "average": 1334.532445923461, - "std_dev": 130.71703964957888 - }, - "tps_summary": { - "max": 1694.0, - "min": 90.0, - "average": 1331.87, - "std_dev": 128.14351238617843 - }, - "revert_summary": { - "max": 0.0, - "min": 0.0, - "average": 0.0, - "std_dev": 0.0 - } -} \ No newline at end of file diff --git a/benchmark_results/run_20241204_145232/config_11_large_prefix_bloom_ratio.rs b/benchmark_results/run_20241204_145232/config_11_large_prefix_bloom_ratio.rs deleted file mode 100644 index 459252751..000000000 --- a/benchmark_results/run_20241204_145232/config_11_large_prefix_bloom_ratio.rs +++ /dev/null @@ -1,80 +0,0 @@ -use rocksdb::BlockBasedOptions; -use rocksdb::Cache; -use rocksdb::Options; - -pub enum CacheSetting { - /// Enabled cache with the given size in bytes - Enabled(usize), - Disabled, -} - -#[derive(Debug, Clone, Copy)] -pub enum DbConfig { - OptimizedPointLookUp, - Default, -} - -impl Default for DbConfig { - fn default() -> Self { - Self::Default - } -} - -impl DbConfig { - pub fn to_options(self, cache_setting: CacheSetting, prefix_len: Option, _key_len: usize) -> Options { - let mut opts = Options::default(); - let mut block_based_options = BlockBasedOptions::default(); - - opts.create_if_missing(true); - opts.create_missing_column_families(true); - opts.increase_parallelism(16); - // add an assertion so that the ulimit -n is at least double this. - // opts.set_max_open_files(40960); - - block_based_options.set_pin_l0_filter_and_index_blocks_in_cache(true); - block_based_options.set_cache_index_and_filter_blocks(true); - block_based_options.set_bloom_filter(15.5, true); - - // NOTE: As per the rocks db wiki: "The overhead of statistics is usually small but non-negligible. We usually observe an overhead of 5%-10%." - #[cfg(feature = "metrics")] - { - opts.enable_statistics(); - opts.set_statistics_level(rocksdb::statistics::StatsLevel::ExceptTimeForMutex); - } - - if let Some(prefix_len) = prefix_len { - let transform = rocksdb::SliceTransform::create_fixed_prefix(prefix_len); - block_based_options.set_index_type(rocksdb::BlockBasedIndexType::HashSearch); - opts.set_memtable_prefix_bloom_ratio(0.25); - opts.set_prefix_extractor(transform); - } - - if let CacheSetting::Enabled(cache_size) = cache_setting { - let block_cache = Cache::new_lru_cache(cache_size/2); - let row_cache = Cache::new_lru_cache(cache_size/2); - - opts.set_row_cache(&row_cache); - block_based_options.set_block_cache(&block_cache); - } - - match self { - DbConfig::OptimizedPointLookUp => { - block_based_options.set_data_block_hash_ratio(0.5); - block_based_options.set_data_block_index_type(rocksdb::DataBlockIndexType::BinaryAndHash); - opts.set_use_direct_reads(true); - opts.set_memtable_whole_key_filtering(true); - opts.set_compression_type(rocksdb::DBCompressionType::None); - } - DbConfig::Default => { - opts.set_compression_type(rocksdb::DBCompressionType::Lz4); - opts.set_bottommost_compression_type(rocksdb::DBCompressionType::Zstd); - opts.set_bottommost_compression_options(-14, 32767, 0, 16 * 1024, true); // mostly defaults except max_dict_bytes - opts.set_bottommost_zstd_max_train_bytes(1600 * 1024, true); - } - } - - opts.set_block_based_table_factory(&block_based_options); - - opts - } -} diff --git a/benchmark_results/run_20241204_145232/results.json b/benchmark_results/run_20241204_145232/results.json deleted file mode 100644 index 3a557308e..000000000 --- a/benchmark_results/run_20241204_145232/results.json +++ /dev/null @@ -1,21 +0,0 @@ -{ - "run_id": "bench-2104943673", - "rps_summary": { - "max": 2153.0, - "min": 216.0, - "average": 1304.6505823627288, - "std_dev": 152.89709557118294 - }, - "tps_summary": { - "max": 1746.0, - "min": 63.0, - "average": 1302.3533333333332, - "std_dev": 154.67231541408935 - }, - "revert_summary": { - "max": 0.0, - "min": 0.0, - "average": 0.0, - "std_dev": 0.0 - } -} \ No newline at end of file diff --git a/benchmark_results/run_20241204_160121/config_12_smaller_block_size.rs b/benchmark_results/run_20241204_160121/config_12_smaller_block_size.rs deleted file mode 100644 index 86777b885..000000000 --- a/benchmark_results/run_20241204_160121/config_12_smaller_block_size.rs +++ /dev/null @@ -1,82 +0,0 @@ -use rocksdb::BlockBasedOptions; -use rocksdb::Cache; -use rocksdb::Options; - -pub enum CacheSetting { - /// Enabled cache with the given size in bytes - Enabled(usize), - Disabled, -} - -#[derive(Debug, Clone, Copy)] -pub enum DbConfig { - OptimizedPointLookUp, - Default, -} - -impl Default for DbConfig { - fn default() -> Self { - Self::Default - } -} - -impl DbConfig { - pub fn to_options(self, cache_setting: CacheSetting, prefix_len: Option, _key_len: usize) -> Options { - let mut opts = Options::default(); - let mut block_based_options = BlockBasedOptions::default(); - - opts.create_if_missing(true); - opts.create_missing_column_families(true); - opts.increase_parallelism(16); - // add an assertion so that the ulimit -n is at least double this. - // opts.set_max_open_files(40960); - - block_based_options.set_pin_l0_filter_and_index_blocks_in_cache(true); - block_based_options.set_cache_index_and_filter_blocks(true); - block_based_options.set_bloom_filter(15.5, true); - - // NOTE: As per the rocks db wiki: "The overhead of statistics is usually small but non-negligible. We usually observe an overhead of 5%-10%." - #[cfg(feature = "metrics")] - { - opts.enable_statistics(); - opts.set_statistics_level(rocksdb::statistics::StatsLevel::ExceptTimeForMutex); - } - - if let Some(prefix_len) = prefix_len { - let transform = rocksdb::SliceTransform::create_fixed_prefix(prefix_len); - block_based_options.set_index_type(rocksdb::BlockBasedIndexType::HashSearch); - opts.set_memtable_prefix_bloom_ratio(0.02); - opts.set_prefix_extractor(transform); - } - - if let CacheSetting::Enabled(cache_size) = cache_setting { - let block_cache = Cache::new_lru_cache(cache_size/2); - let row_cache = Cache::new_lru_cache(cache_size/2); - - opts.set_row_cache(&row_cache); - block_based_options.set_block_cache(&block_cache); - } - - match self { - DbConfig::OptimizedPointLookUp => { - block_based_options.set_data_block_hash_ratio(0.5); - block_based_options.set_data_block_index_type(rocksdb::DataBlockIndexType::BinaryAndHash); - block_based_options.set_block_size(512); - - opts.set_use_direct_reads(true); - opts.set_memtable_whole_key_filtering(true); - opts.set_compression_type(rocksdb::DBCompressionType::None); - } - DbConfig::Default => { - opts.set_compression_type(rocksdb::DBCompressionType::Lz4); - opts.set_bottommost_compression_type(rocksdb::DBCompressionType::Zstd); - opts.set_bottommost_compression_options(-14, 32767, 0, 16 * 1024, true); // mostly defaults except max_dict_bytes - opts.set_bottommost_zstd_max_train_bytes(1600 * 1024, true); - } - } - - opts.set_block_based_table_factory(&block_based_options); - - opts - } -} diff --git a/benchmark_results/run_20241204_160121/results.json b/benchmark_results/run_20241204_160121/results.json deleted file mode 100644 index 8ddbfe1f2..000000000 --- a/benchmark_results/run_20241204_160121/results.json +++ /dev/null @@ -1,21 +0,0 @@ -{ - "run_id": "bench-2658345818", - "rps_summary": { - "max": 2219.0, - "min": 193.0, - "average": 1342.2079866888519, - "std_dev": 127.48546621457129 - }, - "tps_summary": { - "max": 1693.0, - "min": 215.0, - "average": 1340.8848080133555, - "std_dev": 122.1905587214329 - }, - "revert_summary": { - "max": 0.0, - "min": 0.0, - "average": 0.0, - "std_dev": 0.0 - } -} \ No newline at end of file diff --git a/benchmark_results/run_20241204_170819/config_13_larger_block_size.rs b/benchmark_results/run_20241204_170819/config_13_larger_block_size.rs deleted file mode 100644 index 8fdc6d6cf..000000000 --- a/benchmark_results/run_20241204_170819/config_13_larger_block_size.rs +++ /dev/null @@ -1,82 +0,0 @@ -use rocksdb::BlockBasedOptions; -use rocksdb::Cache; -use rocksdb::Options; - -pub enum CacheSetting { - /// Enabled cache with the given size in bytes - Enabled(usize), - Disabled, -} - -#[derive(Debug, Clone, Copy)] -pub enum DbConfig { - OptimizedPointLookUp, - Default, -} - -impl Default for DbConfig { - fn default() -> Self { - Self::Default - } -} - -impl DbConfig { - pub fn to_options(self, cache_setting: CacheSetting, prefix_len: Option, _key_len: usize) -> Options { - let mut opts = Options::default(); - let mut block_based_options = BlockBasedOptions::default(); - - opts.create_if_missing(true); - opts.create_missing_column_families(true); - opts.increase_parallelism(16); - // add an assertion so that the ulimit -n is at least double this. - // opts.set_max_open_files(40960); - - block_based_options.set_pin_l0_filter_and_index_blocks_in_cache(true); - block_based_options.set_cache_index_and_filter_blocks(true); - block_based_options.set_bloom_filter(15.5, true); - - // NOTE: As per the rocks db wiki: "The overhead of statistics is usually small but non-negligible. We usually observe an overhead of 5%-10%." - #[cfg(feature = "metrics")] - { - opts.enable_statistics(); - opts.set_statistics_level(rocksdb::statistics::StatsLevel::ExceptTimeForMutex); - } - - if let Some(prefix_len) = prefix_len { - let transform = rocksdb::SliceTransform::create_fixed_prefix(prefix_len); - block_based_options.set_index_type(rocksdb::BlockBasedIndexType::HashSearch); - opts.set_memtable_prefix_bloom_ratio(0.02); - opts.set_prefix_extractor(transform); - } - - if let CacheSetting::Enabled(cache_size) = cache_setting { - let block_cache = Cache::new_lru_cache(cache_size/2); - let row_cache = Cache::new_lru_cache(cache_size/2); - - opts.set_row_cache(&row_cache); - block_based_options.set_block_cache(&block_cache); - } - - match self { - DbConfig::OptimizedPointLookUp => { - block_based_options.set_data_block_hash_ratio(0.5); - block_based_options.set_data_block_index_type(rocksdb::DataBlockIndexType::BinaryAndHash); - block_based_options.set_block_size(1024*32); - - opts.set_use_direct_reads(true); - opts.set_memtable_whole_key_filtering(true); - opts.set_compression_type(rocksdb::DBCompressionType::None); - } - DbConfig::Default => { - opts.set_compression_type(rocksdb::DBCompressionType::Lz4); - opts.set_bottommost_compression_type(rocksdb::DBCompressionType::Zstd); - opts.set_bottommost_compression_options(-14, 32767, 0, 16 * 1024, true); // mostly defaults except max_dict_bytes - opts.set_bottommost_zstd_max_train_bytes(1600 * 1024, true); - } - } - - opts.set_block_based_table_factory(&block_based_options); - - opts - } -} diff --git a/benchmark_results/run_20241204_170819/results.json b/benchmark_results/run_20241204_170819/results.json deleted file mode 100644 index ab797f5d9..000000000 --- a/benchmark_results/run_20241204_170819/results.json +++ /dev/null @@ -1,21 +0,0 @@ -{ - "run_id": "bench-2609270666", - "rps_summary": { - "max": 2175.0, - "min": 77.0, - "average": 1309.5424292845257, - "std_dev": 151.07310638991387 - }, - "tps_summary": { - "max": 1711.0, - "min": 2.0, - "average": 1306.1466666666668, - "std_dev": 154.3838349338715 - }, - "revert_summary": { - "max": 0.0, - "min": 0.0, - "average": 0.0, - "std_dev": 0.0 - } -} \ No newline at end of file diff --git a/benchmark_results/run_20241204_181544/config_14_HyperClockCache.rs b/benchmark_results/run_20241204_181544/config_14_HyperClockCache.rs deleted file mode 100644 index 6bc4cde08..000000000 --- a/benchmark_results/run_20241204_181544/config_14_HyperClockCache.rs +++ /dev/null @@ -1,81 +0,0 @@ -use rocksdb::BlockBasedOptions; -use rocksdb::Cache; -use rocksdb::Options; - -pub enum CacheSetting { - /// Enabled cache with the given size in bytes - Enabled(usize), - Disabled, -} - -#[derive(Debug, Clone, Copy)] -pub enum DbConfig { - OptimizedPointLookUp, - Default, -} - -impl Default for DbConfig { - fn default() -> Self { - Self::Default - } -} - -impl DbConfig { - pub fn to_options(self, cache_setting: CacheSetting, prefix_len: Option, _key_len: usize) -> Options { - let mut opts = Options::default(); - let mut block_based_options = BlockBasedOptions::default(); - - opts.create_if_missing(true); - opts.create_missing_column_families(true); - opts.increase_parallelism(16); - // add an assertion so that the ulimit -n is at least double this. - // opts.set_max_open_files(40960); - - block_based_options.set_pin_l0_filter_and_index_blocks_in_cache(true); - block_based_options.set_cache_index_and_filter_blocks(true); - block_based_options.set_bloom_filter(15.5, true); - - // NOTE: As per the rocks db wiki: "The overhead of statistics is usually small but non-negligible. We usually observe an overhead of 5%-10%." - #[cfg(feature = "metrics")] - { - opts.enable_statistics(); - opts.set_statistics_level(rocksdb::statistics::StatsLevel::ExceptTimeForMutex); - } - - if let Some(prefix_len) = prefix_len { - let transform = rocksdb::SliceTransform::create_fixed_prefix(prefix_len); - block_based_options.set_index_type(rocksdb::BlockBasedIndexType::HashSearch); - opts.set_memtable_prefix_bloom_ratio(0.02); - opts.set_prefix_extractor(transform); - } - - if let CacheSetting::Enabled(cache_size) = cache_setting { - // the documentation states that passing 0 to the estimated entry charge makes it so rocks estimates a good value - let block_cache = Cache::new_hyper_clock_cache(cache_size/2, 0); - let row_cache = Cache::new_hyper_clock_cache(cache_size/2, 0); - - opts.set_row_cache(&row_cache); - block_based_options.set_block_cache(&block_cache); - } - - match self { - DbConfig::OptimizedPointLookUp => { - block_based_options.set_data_block_hash_ratio(0.5); - block_based_options.set_data_block_index_type(rocksdb::DataBlockIndexType::BinaryAndHash); - opts.set_use_direct_reads(true); - opts.set_memtable_whole_key_filtering(true); - opts.set_compression_type(rocksdb::DBCompressionType::None); - } - DbConfig::Default => { - opts.set_compression_type(rocksdb::DBCompressionType::Lz4); - opts.set_bottommost_compression_type(rocksdb::DBCompressionType::Zstd); - opts.set_bottommost_compression_options(-14, 32767, 0, 16 * 1024, true); // mostly defaults except max_dict_bytes - opts.set_bottommost_zstd_max_train_bytes(1600 * 1024, true); - } - } - - opts.set_block_based_table_factory(&block_based_options); - - opts - } -} diff --git a/benchmark_results/run_20241204_181544/results.json b/benchmark_results/run_20241204_181544/results.json deleted file mode 100644 index b012bad1e..000000000 --- a/benchmark_results/run_20241204_181544/results.json +++ /dev/null @@ -1,21 +0,0 @@ -{ - "run_id": "bench-3332455529", - "rps_summary": { - "max": 2559.0, - "min": 151.0, - "average": 1334.8036605657237, - "std_dev": 127.67884805053677 - }, - "tps_summary": { - "max": 1677.0, - "min": 477.0, - "average": 1333.3856427378964, - "std_dev": 115.26790972585063 - }, - "revert_summary": { - "max": 0.0, - "min": 0.0, - "average": 0.0, - "std_dev": 0.0 - } -} \ No newline at end of file diff --git a/benchmark_results/run_20241209_160845/config_01_minimal.rs b/benchmark_results/run_20241209_160845/config_01_minimal.rs deleted file mode 100644 index d3a75f278..000000000 --- a/benchmark_results/run_20241209_160845/config_01_minimal.rs +++ /dev/null @@ -1,63 +0,0 @@ -use rocksdb::BlockBasedOptions; -use rocksdb::Cache; -use rocksdb::Options; - -pub enum CacheSetting { - /// Enabled cache with the given size in bytes - Enabled(usize), - Disabled, -} - -#[derive(Debug, Clone, Copy)] -pub enum DbConfig { - OptimizedPointLookUp, - Default, -} - -impl Default for DbConfig { - fn default() -> Self { - Self::Default - } -} - -impl DbConfig { - pub fn to_options(self, cache_setting: CacheSetting, _prefix_len: Option, _key_len: usize) -> Options { - let mut opts = Options::default(); - let mut block_based_options = BlockBasedOptions::default(); - - opts.create_if_missing(true); - opts.create_missing_column_families(true); - opts.increase_parallelism(16); - block_based_options.set_pin_l0_filter_and_index_blocks_in_cache(true); - block_based_options.set_cache_index_and_filter_blocks(true); - block_based_options.set_ribbon_filter(15.5); - - // NOTE: As per the rocks db wiki: "The overhead of statistics is usually small but non-negligible. We usually observe an overhead of 5%-10%." - #[cfg(feature = "metrics")] - { - opts.enable_statistics(); - opts.set_statistics_level(rocksdb::statistics::StatsLevel::ExceptTimeForMutex); - } - - if let CacheSetting::Enabled(cache_size) = cache_setting { - let cache = Cache::new_lru_cache(cache_size); - block_based_options.set_block_cache(&cache); - block_based_options.set_cache_index_and_filter_blocks(true); - } - - match self { - DbConfig::OptimizedPointLookUp => { - opts.set_compression_type(rocksdb::DBCompressionType::None); - } - DbConfig::Default => { - opts.set_compression_type(rocksdb::DBCompressionType::Lz4); - opts.set_bottommost_compression_type(rocksdb::DBCompressionType::Zstd); - opts.set_bottommost_compression_options(-14, 32767, 0, 16 * 1024, true); // mostry defaults except max_dict_bytes - opts.set_bottommost_zstd_max_train_bytes(1600 * 1024, true); - } - } - - opts.set_block_based_table_factory(&block_based_options); - opts - } -} diff --git a/benchmark_results/run_20241209_160845/results.json b/benchmark_results/run_20241209_160845/results.json deleted file mode 100644 index aa0d954ca..000000000 --- a/benchmark_results/run_20241209_160845/results.json +++ /dev/null @@ -1,21 +0,0 @@ -{ - "run_id": "bench-3020545129", - "rps_summary": { - "max": 2158.0, - "min": 197.0, - "average": 1092.5315190224937, - "std_dev": 103.93295730765874 - }, - "tps_summary": { - "max": 1480.0, - "min": 157.0, - "average": 1092.2333981661573, - "std_dev": 102.52949473041909 - }, - "revert_summary": { - "max": 0.0, - "min": 0.0, - "average": 0.0, - "std_dev": 0.0 - } -} \ No newline at end of file diff --git a/benchmark_results/run_20241209_183211/config_02_OptimizeForPointLookup.rs b/benchmark_results/run_20241209_183211/config_02_OptimizeForPointLookup.rs deleted file mode 100644 index 7b5cc6c9e..000000000 --- a/benchmark_results/run_20241209_183211/config_02_OptimizeForPointLookup.rs +++ /dev/null @@ -1,68 +0,0 @@ -use rocksdb::BlockBasedOptions; -use rocksdb::Cache; -use rocksdb::Options; - -pub enum CacheSetting { - /// Enabled cache with the given size in bytes - Enabled(usize), - Disabled, -} - -#[derive(Debug, Clone, Copy)] -pub enum DbConfig { - OptimizedPointLookUp, - Default, -} - -impl Default for DbConfig { - fn default() -> Self { - Self::Default - } -} - -impl DbConfig { - pub fn to_options(self, cache_setting: CacheSetting, _prefix_len: Option, _key_len: usize) -> Options { - let mut opts = Options::default(); - let mut block_based_options = BlockBasedOptions::default(); - - opts.create_if_missing(true); - opts.create_missing_column_families(true); - opts.increase_parallelism(16); - block_based_options.set_pin_l0_filter_and_index_blocks_in_cache(true); - block_based_options.set_cache_index_and_filter_blocks(true); - block_based_options.set_bloom_filter(15.5, true); - - // NOTE: As per the rocks db wiki: "The overhead of statistics is usually small but non-negligible. We usually observe an overhead of 5%-10%." - #[cfg(feature = "metrics")] - { - opts.enable_statistics(); - opts.set_statistics_level(rocksdb::statistics::StatsLevel::ExceptTimeForMutex); - } - - if let CacheSetting::Enabled(cache_size) = cache_setting { - let cache = Cache::new_lru_cache(cache_size); - block_based_options.set_block_cache(&cache); - } - - match self { - DbConfig::OptimizedPointLookUp => { - block_based_options.set_data_block_hash_ratio(0.5); - block_based_options.set_data_block_index_type(rocksdb::DataBlockIndexType::BinaryAndHash); - opts.set_memtable_whole_key_filtering(true); - opts.set_memtable_prefix_bloom_ratio(0.02); - opts.set_compression_type(rocksdb::DBCompressionType::None); - } - DbConfig::Default => { - opts.set_compression_type(rocksdb::DBCompressionType::Lz4); - opts.set_bottommost_compression_type(rocksdb::DBCompressionType::Zstd); - opts.set_bottommost_compression_options(-14, 32767, 0, 16 * 1024, true); // mostly defaults except max_dict_bytes - opts.set_bottommost_zstd_max_train_bytes(1600 * 1024, true); - } - } - - - - opts.set_block_based_table_factory(&block_based_options); - opts - } -} diff --git a/benchmark_results/run_20241209_183211/results.json b/benchmark_results/run_20241209_183211/results.json deleted file mode 100644 index 0963f7b1f..000000000 --- a/benchmark_results/run_20241209_183211/results.json +++ /dev/null @@ -1,21 +0,0 @@ -{ - "run_id": "bench-2842389973", - "rps_summary": { - "max": 2139.0, - "min": 167.0, - "average": 1200.5837267425716, - "std_dev": 91.3662094451633 - }, - "tps_summary": { - "max": 1567.0, - "min": 9.0, - "average": 1200.0952777777777, - "std_dev": 92.26148275376251 - }, - "revert_summary": { - "max": 0.0, - "min": 0.0, - "average": 0.0, - "std_dev": 0.0 - } -} \ No newline at end of file diff --git a/benchmark_results/run_20241209_205115/config_03_PrefixExtractor.rs b/benchmark_results/run_20241209_205115/config_03_PrefixExtractor.rs deleted file mode 100644 index 40a3204c9..000000000 --- a/benchmark_results/run_20241209_205115/config_03_PrefixExtractor.rs +++ /dev/null @@ -1,72 +0,0 @@ -use rocksdb::BlockBasedOptions; -use rocksdb::Cache; -use rocksdb::Options; - -pub enum CacheSetting { - /// Enabled cache with the given size in bytes - Enabled(usize), - Disabled, -} - -#[derive(Debug, Clone, Copy)] -pub enum DbConfig { - OptimizedPointLookUp, - Default, -} - -impl Default for DbConfig { - fn default() -> Self { - Self::Default - } -} - -impl DbConfig { - pub fn to_options(self, cache_setting: CacheSetting, prefix_len: Option, _key_len: usize) -> Options { - let mut opts = Options::default(); - let mut block_based_options = BlockBasedOptions::default(); - - opts.create_if_missing(true); - opts.create_missing_column_families(true); - opts.increase_parallelism(16); - - block_based_options.set_pin_l0_filter_and_index_blocks_in_cache(true); - block_based_options.set_cache_index_and_filter_blocks(true); - block_based_options.set_bloom_filter(15.5, true); - - // NOTE: As per the rocks db wiki: "The overhead of statistics is usually small but non-negligible. We usually observe an overhead of 5%-10%." - #[cfg(feature = "metrics")] - { - opts.enable_statistics(); - opts.set_statistics_level(rocksdb::statistics::StatsLevel::ExceptTimeForMutex); - } - - if let Some(prefix_len) = prefix_len { - let transform = rocksdb::SliceTransform::create_fixed_prefix(prefix_len); - opts.set_memtable_prefix_bloom_ratio(0.02); - opts.set_prefix_extractor(transform); - } - - if let CacheSetting::Enabled(cache_size) = cache_setting { - let cache = Cache::new_lru_cache(cache_size); - block_based_options.set_block_cache(&cache); - } - - match self { - DbConfig::OptimizedPointLookUp => { - block_based_options.set_data_block_hash_ratio(0.5); - block_based_options.set_data_block_index_type(rocksdb::DataBlockIndexType::BinaryAndHash); - opts.set_memtable_whole_key_filtering(true); - opts.set_compression_type(rocksdb::DBCompressionType::None); - } - DbConfig::Default => { - opts.set_compression_type(rocksdb::DBCompressionType::Lz4); - opts.set_bottommost_compression_type(rocksdb::DBCompressionType::Zstd); - opts.set_bottommost_compression_options(-14, 32767, 0, 16 * 1024, true); // mostly defaults except max_dict_bytes - opts.set_bottommost_zstd_max_train_bytes(1600 * 1024, true); - } - } - - opts.set_block_based_table_factory(&block_based_options); - opts - } -} diff --git a/benchmark_results/run_20241209_205115/results.json b/benchmark_results/run_20241209_205115/results.json deleted file mode 100644 index cc6ed9574..000000000 --- a/benchmark_results/run_20241209_205115/results.json +++ /dev/null @@ -1,21 +0,0 @@ -{ - "run_id": "bench-3520083885", - "rps_summary": { - "max": 2127.0, - "min": 183.0, - "average": 1172.2957511802276, - "std_dev": 94.48599605459269 - }, - "tps_summary": { - "max": 1558.0, - "min": 31.0, - "average": 1171.8725, - "std_dev": 96.57881996572641 - }, - "revert_summary": { - "max": 0.0, - "min": 0.0, - "average": 0.0, - "std_dev": 0.0 - } -} \ No newline at end of file diff --git a/benchmark_results/run_20241209_231505/config_04_RowCache.rs b/benchmark_results/run_20241209_231505/config_04_RowCache.rs deleted file mode 100644 index d22f43061..000000000 --- a/benchmark_results/run_20241209_231505/config_04_RowCache.rs +++ /dev/null @@ -1,76 +0,0 @@ -use rocksdb::BlockBasedOptions; -use rocksdb::Cache; -use rocksdb::Options; - -pub enum CacheSetting { - /// Enabled cache with the given size in bytes - Enabled(usize), - Disabled, -} - -#[derive(Debug, Clone, Copy)] -pub enum DbConfig { - OptimizedPointLookUp, - Default, -} - -impl Default for DbConfig { - fn default() -> Self { - Self::Default - } -} - -impl DbConfig { - pub fn to_options(self, cache_setting: CacheSetting, prefix_len: Option, _key_len: usize) -> Options { - let mut opts = Options::default(); - let mut block_based_options = BlockBasedOptions::default(); - - opts.create_if_missing(true); - opts.create_missing_column_families(true); - opts.increase_parallelism(16); - - block_based_options.set_pin_l0_filter_and_index_blocks_in_cache(true); - block_based_options.set_cache_index_and_filter_blocks(true); - block_based_options.set_bloom_filter(15.5, true); - - // NOTE: As per the rocks db wiki: "The overhead of statistics is usually small but non-negligible. We usually observe an overhead of 5%-10%." - #[cfg(feature = "metrics")] - { - opts.enable_statistics(); - opts.set_statistics_level(rocksdb::statistics::StatsLevel::ExceptTimeForMutex); - } - - if let Some(prefix_len) = prefix_len { - let transform = rocksdb::SliceTransform::create_fixed_prefix(prefix_len); - opts.set_memtable_prefix_bloom_ratio(0.02); - opts.set_prefix_extractor(transform); - } - - if let CacheSetting::Enabled(cache_size) = cache_setting { - let block_cache = Cache::new_lru_cache(cache_size/2); - let row_cache = Cache::new_lru_cache(cache_size/2); - - opts.set_row_cache(&row_cache); - block_based_options.set_block_cache(&block_cache); - } - - match self { - DbConfig::OptimizedPointLookUp => { - block_based_options.set_data_block_hash_ratio(0.5); - block_based_options.set_data_block_index_type(rocksdb::DataBlockIndexType::BinaryAndHash); - opts.set_memtable_whole_key_filtering(true); - opts.set_compression_type(rocksdb::DBCompressionType::None); - } - DbConfig::Default => { - opts.set_compression_type(rocksdb::DBCompressionType::Lz4); - opts.set_bottommost_compression_type(rocksdb::DBCompressionType::Zstd); - opts.set_bottommost_compression_options(-14, 32767, 0, 16 * 1024, true); // mostly defaults except max_dict_bytes - opts.set_bottommost_zstd_max_train_bytes(1600 * 1024, true); - } - } - - opts.set_block_based_table_factory(&block_based_options); - - opts - } -} diff --git a/benchmark_results/run_20241209_231505/results.json b/benchmark_results/run_20241209_231505/results.json deleted file mode 100644 index 75ee24b34..000000000 --- a/benchmark_results/run_20241209_231505/results.json +++ /dev/null @@ -1,21 +0,0 @@ -{ - "run_id": "bench-2654172327", - "rps_summary": { - "max": 2298.0, - "min": 183.0, - "average": 1137.1382949180784, - "std_dev": 101.33738460050336 - }, - "tps_summary": { - "max": 1498.0, - "min": 176.0, - "average": 1136.776388888889, - "std_dev": 101.58069451461249 - }, - "revert_summary": { - "max": 0.0, - "min": 0.0, - "average": 0.0, - "std_dev": 0.0 - } -} \ No newline at end of file diff --git a/benchmark_results/run_20241210_014005/config_05_HashSearchIndexType.rs b/benchmark_results/run_20241210_014005/config_05_HashSearchIndexType.rs deleted file mode 100644 index 73cb195ac..000000000 --- a/benchmark_results/run_20241210_014005/config_05_HashSearchIndexType.rs +++ /dev/null @@ -1,77 +0,0 @@ -use rocksdb::BlockBasedOptions; -use rocksdb::Cache; -use rocksdb::Options; - -pub enum CacheSetting { - /// Enabled cache with the given size in bytes - Enabled(usize), - Disabled, -} - -#[derive(Debug, Clone, Copy)] -pub enum DbConfig { - OptimizedPointLookUp, - Default, -} - -impl Default for DbConfig { - fn default() -> Self { - Self::Default - } -} - -impl DbConfig { - pub fn to_options(self, cache_setting: CacheSetting, prefix_len: Option, _key_len: usize) -> Options { - let mut opts = Options::default(); - let mut block_based_options = BlockBasedOptions::default(); - - opts.create_if_missing(true); - opts.create_missing_column_families(true); - opts.increase_parallelism(16); - - block_based_options.set_pin_l0_filter_and_index_blocks_in_cache(true); - block_based_options.set_cache_index_and_filter_blocks(true); - block_based_options.set_bloom_filter(15.5, true); - - // NOTE: As per the rocks db wiki: "The overhead of statistics is usually small but non-negligible. We usually observe an overhead of 5%-10%." - #[cfg(feature = "metrics")] - { - opts.enable_statistics(); - opts.set_statistics_level(rocksdb::statistics::StatsLevel::ExceptTimeForMutex); - } - - if let Some(prefix_len) = prefix_len { - let transform = rocksdb::SliceTransform::create_fixed_prefix(prefix_len); - block_based_options.set_index_type(rocksdb::BlockBasedIndexType::HashSearch); - opts.set_memtable_prefix_bloom_ratio(0.02); - opts.set_prefix_extractor(transform); - } - - if let CacheSetting::Enabled(cache_size) = cache_setting { - let block_cache = Cache::new_lru_cache(cache_size/2); - let row_cache = Cache::new_lru_cache(cache_size/2); - - opts.set_row_cache(&row_cache); - block_based_options.set_block_cache(&block_cache); - } - - match self { - DbConfig::OptimizedPointLookUp => { - block_based_options.set_data_block_hash_ratio(0.5); - block_based_options.set_data_block_index_type(rocksdb::DataBlockIndexType::BinaryAndHash); - opts.set_memtable_whole_key_filtering(true); - opts.set_compression_type(rocksdb::DBCompressionType::None); - } - DbConfig::Default => { - opts.set_compression_type(rocksdb::DBCompressionType::Lz4); - opts.set_bottommost_compression_type(rocksdb::DBCompressionType::Zstd); - opts.set_bottommost_compression_options(-14, 32767, 0, 16 * 1024, true); // mostly defaults except max_dict_bytes - opts.set_bottommost_zstd_max_train_bytes(1600 * 1024, true); - } - } - - opts.set_block_based_table_factory(&block_based_options); - - opts - } -} diff --git a/benchmark_results/run_20241210_014005/results.json b/benchmark_results/run_20241210_014005/results.json deleted file mode 100644 index a30873861..000000000 --- a/benchmark_results/run_20241210_014005/results.json +++ /dev/null @@ -1,21 +0,0 @@ -{ - "run_id": "bench-2276197718", - "rps_summary": { - "max": 2360.0, - "min": 149.0, - "average": 1205.326298250486, - "std_dev": 83.48002203700591 - }, - "tps_summary": { - "max": 1575.0, - "min": 209.0, - "average": 1204.9783333333332, - "std_dev": 82.53860764986148 - }, - "revert_summary": { - "max": 0.0, - "min": 0.0, - "average": 0.0, - "std_dev": 0.0 - } -} \ No newline at end of file diff --git a/benchmark_results/run_20241210_040254/config_06_DirectIO.rs b/benchmark_results/run_20241210_040254/config_06_DirectIO.rs deleted file mode 100644 index e130a7129..000000000 --- a/benchmark_results/run_20241210_040254/config_06_DirectIO.rs +++ /dev/null @@ -1,80 +0,0 @@ -use rocksdb::BlockBasedOptions; -use rocksdb::Cache; -use rocksdb::Options; - -pub enum CacheSetting { - /// Enabled cache with the given size in bytes - Enabled(usize), - Disabled, -} - -#[derive(Debug, Clone, Copy)] -pub enum DbConfig { - OptimizedPointLookUp, - Default, -} - -impl Default for DbConfig { - fn default() -> Self { - Self::Default - } -} - -impl DbConfig { - pub fn to_options(self, cache_setting: CacheSetting, prefix_len: Option, _key_len: usize) -> Options { - let mut opts = Options::default(); - let mut block_based_options = BlockBasedOptions::default(); - - opts.create_if_missing(true); - opts.create_missing_column_families(true); - opts.increase_parallelism(16); - // add an assertion so that the ulimit -n is at least double this. - // opts.set_max_open_files(40960); - - block_based_options.set_pin_l0_filter_and_index_blocks_in_cache(true); - block_based_options.set_cache_index_and_filter_blocks(true); - block_based_options.set_bloom_filter(15.5, true); - - // NOTE: As per the rocks db wiki: "The overhead of statistics is usually small but non-negligible. We usually observe an overhead of 5%-10%." - #[cfg(feature = "metrics")] - { - opts.enable_statistics(); - opts.set_statistics_level(rocksdb::statistics::StatsLevel::ExceptTimeForMutex); - } - - if let Some(prefix_len) = prefix_len { - let transform = rocksdb::SliceTransform::create_fixed_prefix(prefix_len); - block_based_options.set_index_type(rocksdb::BlockBasedIndexType::HashSearch); - opts.set_memtable_prefix_bloom_ratio(0.02); - opts.set_prefix_extractor(transform); - } - - if let CacheSetting::Enabled(cache_size) = cache_setting { - let block_cache = Cache::new_lru_cache(cache_size/2); - let row_cache = Cache::new_lru_cache(cache_size/2); - - opts.set_row_cache(&row_cache); - block_based_options.set_block_cache(&block_cache); - } - - match self { - DbConfig::OptimizedPointLookUp => { - block_based_options.set_data_block_hash_ratio(0.5); - block_based_options.set_data_block_index_type(rocksdb::DataBlockIndexType::BinaryAndHash); - opts.set_use_direct_reads(true); - opts.set_memtable_whole_key_filtering(true); - opts.set_compression_type(rocksdb::DBCompressionType::None); - } - DbConfig::Default => { - opts.set_compression_type(rocksdb::DBCompressionType::Lz4); - opts.set_bottommost_compression_type(rocksdb::DBCompressionType::Zstd); - opts.set_bottommost_compression_options(-14, 32767, 0, 16 * 1024, true); // mostly defaults except max_dict_bytes - opts.set_bottommost_zstd_max_train_bytes(1600 * 1024, true); - } - } - - opts.set_block_based_table_factory(&block_based_options); - - opts - } -} diff --git a/benchmark_results/run_20241210_040254/results.json b/benchmark_results/run_20241210_040254/results.json deleted file mode 100644 index 23685be54..000000000 --- a/benchmark_results/run_20241210_040254/results.json +++ /dev/null @@ -1,21 +0,0 @@ -{ - "run_id": "bench-3752377383", - "rps_summary": { - "max": 2382.0, - "min": 157.0, - "average": 1149.221327409053, - "std_dev": 105.38340969344118 - }, - "tps_summary": { - "max": 1536.0, - "min": 323.0, - "average": 1148.9213670464019, - "std_dev": 105.2367932193355 - }, - "revert_summary": { - "max": 0.0, - "min": 0.0, - "average": 0.0, - "std_dev": 0.0 - } -} \ No newline at end of file diff --git a/benchmark_results/run_20241210_062800/config_07_HashSkipList.rs b/benchmark_results/run_20241210_062800/config_07_HashSkipList.rs deleted file mode 100644 index cbe7e107e..000000000 --- a/benchmark_results/run_20241210_062800/config_07_HashSkipList.rs +++ /dev/null @@ -1,81 +0,0 @@ -use rocksdb::BlockBasedOptions; -use rocksdb::Cache; -use rocksdb::MemtableFactory; -use rocksdb::Options; - -pub enum CacheSetting { - /// Enabled cache with the given size in bytes - Enabled(usize), - Disabled, -} - -#[derive(Debug, Clone, Copy)] -pub enum DbConfig { - OptimizedPointLookUp, - Default, -} - -impl Default for DbConfig { - fn default() -> Self { - Self::Default - } -} - -impl DbConfig { - pub fn to_options(self, cache_setting: CacheSetting, prefix_len: Option, _key_len: usize) -> Options { - let mut opts = Options::default(); - let mut block_based_options = BlockBasedOptions::default(); - - opts.create_if_missing(true); - opts.create_missing_column_families(true); - opts.increase_parallelism(16); - block_based_options.set_pin_l0_filter_and_index_blocks_in_cache(true); - block_based_options.set_cache_index_and_filter_blocks(true); - block_based_options.set_bloom_filter(15.5, true); - - opts.set_allow_concurrent_memtable_write(false); - - // NOTE: As per the rocks db wiki: "The overhead of statistics is usually small but non-negligible. We usually observe an overhead of 5%-10%." - #[cfg(feature = "metrics")] - { - opts.enable_statistics(); - opts.set_statistics_level(rocksdb::statistics::StatsLevel::ExceptTimeForMutex); - } - - if let Some(prefix_len) = prefix_len { - let transform = rocksdb::SliceTransform::create_fixed_prefix(prefix_len); - block_based_options.set_index_type(rocksdb::BlockBasedIndexType::HashSearch); - opts.set_memtable_whole_key_filtering(true); - opts.set_memtable_factory(MemtableFactory::HashSkipList { bucket_count: 10000, height: 4, branching_factor: 4 }); - opts.set_memtable_prefix_bloom_ratio(0.2); - opts.set_prefix_extractor(transform); - } - - if let CacheSetting::Enabled(cache_size) = cache_setting { - let block_cache = Cache::new_lru_cache(cache_size/2); - let row_cache = Cache::new_lru_cache(cache_size/2); - - opts.set_row_cache(&row_cache); - block_based_options.set_block_cache(&block_cache); - } - - match self { - DbConfig::OptimizedPointLookUp => { - block_based_options.set_data_block_hash_ratio(0.5); - block_based_options.set_data_block_index_type(rocksdb::DataBlockIndexType::BinaryAndHash); - opts.set_use_direct_reads(true); - opts.set_compression_type(rocksdb::DBCompressionType::None); - } - DbConfig::Default => { - opts.set_compression_type(rocksdb::DBCompressionType::Lz4); - opts.set_bottommost_compression_type(rocksdb::DBCompressionType::Zstd); - opts.set_bottommost_compression_options(-14, 32767, 0, 16 * 1024, true); // mostly defaults except max_dict_bytes - opts.set_bottommost_zstd_max_train_bytes(1600 * 1024, true); - } - } - - opts.set_block_based_table_factory(&block_based_options); - - opts - } -} diff --git a/benchmark_results/run_20241210_062800/results.json b/benchmark_results/run_20241210_062800/results.json deleted file mode 100644 index 64696c7e6..000000000 --- a/benchmark_results/run_20241210_062800/results.json +++ /dev/null @@ -1,21 +0,0 @@ -{ - "run_id": "bench-2748229537", - "rps_summary": { - "max": 2196.0, - "min": 128.0, - "average": 1198.1724520966397, - "std_dev": 78.50697520689886 - }, - "tps_summary": { - "max": 1544.0, - "min": 40.0, - "average": 1197.706111111111, - "std_dev": 78.7183147289462 - }, - "revert_summary": { - "max": 0.0, - "min": 0.0, - "average": 0.0, - "std_dev": 0.0 - } -} \ No newline at end of file diff --git a/benchmark_results/run_20241210_085046/config_08_PlainTable.rs b/benchmark_results/run_20241210_085046/config_08_PlainTable.rs deleted file mode 100644 index 4d67d34c9..000000000 --- a/benchmark_results/run_20241210_085046/config_08_PlainTable.rs +++ /dev/null @@ -1,94 +0,0 @@ -use rocksdb::BlockBasedOptions; -use rocksdb::Cache; -use rocksdb::Options; -use rocksdb::PlainTableFactoryOptions; - -pub enum CacheSetting { - /// Enabled cache with the given size in bytes - Enabled(usize), - Disabled, -} - -#[derive(Debug, Clone, Copy)] -pub enum DbConfig { - OptimizedPointLookUp, - Default, -} - -impl Default for DbConfig { - fn default() -> Self { - Self::Default - } -} - -impl DbConfig { - pub fn to_options(self, cache_setting: CacheSetting, prefix_len: Option, key_len: usize) -> Options { - let mut opts = Options::default(); - let mut block_based_options = BlockBasedOptions::default(); - - opts.create_if_missing(true); - opts.create_missing_column_families(true); - opts.increase_parallelism(16); - // add an assertion so that the ulimit -n is at least double this. - // opts.set_max_open_files(40960); - - block_based_options.set_pin_l0_filter_and_index_blocks_in_cache(true); - block_based_options.set_cache_index_and_filter_blocks(true); - block_based_options.set_bloom_filter(15.5, true); - opts.set_allow_concurrent_memtable_write(false); - - // NOTE: As per the rocks db wiki: "The overhead of statistics is usually small but non-negligible. We usually observe an overhead of 5%-10%." - #[cfg(feature = "metrics")] - { - opts.enable_statistics(); - opts.set_statistics_level(rocksdb::statistics::StatsLevel::ExceptTimeForMutex); - } - - if let Some(prefix_len) = prefix_len { - let transform = rocksdb::SliceTransform::create_fixed_prefix(prefix_len); - block_based_options.set_index_type(rocksdb::BlockBasedIndexType::HashSearch); - opts.set_memtable_whole_key_filtering(true); - opts.set_memtable_prefix_bloom_ratio(0.2); - opts.set_prefix_extractor(transform); - } - - if let CacheSetting::Enabled(cache_size) = cache_setting { - let block_cache = Cache::new_lru_cache(cache_size/2); - let row_cache = Cache::new_lru_cache(cache_size/2); - - opts.set_row_cache(&row_cache); - block_based_options.set_block_cache(&block_cache); - } - - match self { - DbConfig::OptimizedPointLookUp => { - let plain = PlainTableFactoryOptions { - user_key_length: key_len as u32, - bloom_bits_per_key: 15, - hash_table_ratio: 0.75, - index_sparseness: 16, - huge_page_tlb_size: 0, - encoding_type: rocksdb::KeyEncodingType::Plain, - full_scan_mode: false, - store_index_in_file: true - }; - - opts.set_use_direct_reads(true); - opts.set_memtable_whole_key_filtering(true); - - opts.set_compression_type(rocksdb::DBCompressionType::None); - opts.set_plain_table_factory(&plain); - } - DbConfig::Default => { - opts.set_compression_type(rocksdb::DBCompressionType::Lz4); - opts.set_bottommost_compression_type(rocksdb::DBCompressionType::Zstd); - opts.set_bottommost_compression_options(-14, 32767, 0, 16 * 1024, true); // mostly defaults except max_dict_bytes - opts.set_bottommost_zstd_max_train_bytes(1600 * 1024, true); - } - } - - opts.set_block_based_table_factory(&block_based_options); - - opts - } -} diff --git a/benchmark_results/run_20241210_085046/results.json b/benchmark_results/run_20241210_085046/results.json deleted file mode 100644 index 31b70c8ef..000000000 --- a/benchmark_results/run_20241210_085046/results.json +++ /dev/null @@ -1,21 +0,0 @@ -{ - "run_id": "bench-1188570922", - "rps_summary": { - "max": 2356.0, - "min": 94.0, - "average": 1135.2179950013885, - "std_dev": 107.67759156414704 - }, - "tps_summary": { - "max": 1498.0, - "min": 37.0, - "average": 1134.6586111111112, - "std_dev": 106.60589861866552 - }, - "revert_summary": { - "max": 0.0, - "min": 0.0, - "average": 0.0, - "std_dev": 0.0 - } -} \ No newline at end of file diff --git a/benchmark_results/run_20241210_111454/config_09_small_hash_ratio.rs b/benchmark_results/run_20241210_111454/config_09_small_hash_ratio.rs deleted file mode 100644 index 6c5e04b66..000000000 --- a/benchmark_results/run_20241210_111454/config_09_small_hash_ratio.rs +++ /dev/null @@ -1,80 +0,0 @@ -use rocksdb::BlockBasedOptions; -use rocksdb::Cache; -use rocksdb::Options; - -pub enum CacheSetting { - /// Enabled cache with the given size in bytes - Enabled(usize), - Disabled, -} - -#[derive(Debug, Clone, Copy)] -pub enum DbConfig { - OptimizedPointLookUp, - Default, -} - -impl Default for DbConfig { - fn default() -> Self { - Self::Default - } -} - -impl DbConfig { - pub fn to_options(self, cache_setting: CacheSetting, prefix_len: Option, _key_len: usize) -> Options { - let mut opts = Options::default(); - let mut block_based_options = BlockBasedOptions::default(); - - opts.create_if_missing(true); - opts.create_missing_column_families(true); - opts.increase_parallelism(16); - // add an assertion so that the ulimit -n is at least double this. - // opts.set_max_open_files(40960); - - block_based_options.set_pin_l0_filter_and_index_blocks_in_cache(true); - block_based_options.set_cache_index_and_filter_blocks(true); - block_based_options.set_bloom_filter(15.5, true); - - // NOTE: As per the rocks db wiki: "The overhead of statistics is usually small but non-negligible. We usually observe an overhead of 5%-10%." - #[cfg(feature = "metrics")] - { - opts.enable_statistics(); - opts.set_statistics_level(rocksdb::statistics::StatsLevel::ExceptTimeForMutex); - } - - if let Some(prefix_len) = prefix_len { - let transform = rocksdb::SliceTransform::create_fixed_prefix(prefix_len); - block_based_options.set_index_type(rocksdb::BlockBasedIndexType::HashSearch); - opts.set_memtable_prefix_bloom_ratio(0.02); - opts.set_prefix_extractor(transform); - } - - if let CacheSetting::Enabled(cache_size) = cache_setting { - let block_cache = Cache::new_lru_cache(cache_size/2); - let row_cache = Cache::new_lru_cache(cache_size/2); - - opts.set_row_cache(&row_cache); - block_based_options.set_block_cache(&block_cache); - } - - match self { - DbConfig::OptimizedPointLookUp => { - block_based_options.set_data_block_hash_ratio(0.1); - block_based_options.set_data_block_index_type(rocksdb::DataBlockIndexType::BinaryAndHash); - opts.set_use_direct_reads(true); - opts.set_memtable_whole_key_filtering(true); - opts.set_compression_type(rocksdb::DBCompressionType::None); - } - DbConfig::Default => { - opts.set_compression_type(rocksdb::DBCompressionType::Lz4); - opts.set_bottommost_compression_type(rocksdb::DBCompressionType::Zstd); - opts.set_bottommost_compression_options(-14, 32767, 0, 16 * 1024, true); // mostly defaults except max_dict_bytes - opts.set_bottommost_zstd_max_train_bytes(1600 * 1024, true); - } - } - - opts.set_block_based_table_factory(&block_based_options); - - opts - } -} diff --git a/benchmark_results/run_20241210_111454/results.json b/benchmark_results/run_20241210_111454/results.json deleted file mode 100644 index 0f5d363d7..000000000 --- a/benchmark_results/run_20241210_111454/results.json +++ /dev/null @@ -1,21 +0,0 @@ -{ - "run_id": "bench-918150529", - "rps_summary": { - "max": 2265.0, - "min": 145.0, - "average": 1201.5367953346292, - "std_dev": 73.79128264764255 - }, - "tps_summary": { - "max": 1508.0, - "min": 34.0, - "average": 1201.0280555555555, - "std_dev": 73.53637453364479 - }, - "revert_summary": { - "max": 0.0, - "min": 0.0, - "average": 0.0, - "std_dev": 0.0 - } -} \ No newline at end of file diff --git a/benchmark_results/run_20241210_133544/config_10_large_hash_ratio.rs b/benchmark_results/run_20241210_133544/config_10_large_hash_ratio.rs deleted file mode 100644 index f424ac7bc..000000000 --- a/benchmark_results/run_20241210_133544/config_10_large_hash_ratio.rs +++ /dev/null @@ -1,80 +0,0 @@ -use rocksdb::BlockBasedOptions; -use rocksdb::Cache; -use rocksdb::Options; - -pub enum CacheSetting { - /// Enabled cache with the given size in bytes - Enabled(usize), - Disabled, -} - -#[derive(Debug, Clone, Copy)] -pub enum DbConfig { - OptimizedPointLookUp, - Default, -} - -impl Default for DbConfig { - fn default() -> Self { - Self::Default - } -} - -impl DbConfig { - pub fn to_options(self, cache_setting: CacheSetting, prefix_len: Option, _key_len: usize) -> Options { - let mut opts = Options::default(); - let mut block_based_options = BlockBasedOptions::default(); - - opts.create_if_missing(true); - opts.create_missing_column_families(true); - opts.increase_parallelism(16); - // add an assertion so that the ulimit -n is at least double this. - // opts.set_max_open_files(40960); - - block_based_options.set_pin_l0_filter_and_index_blocks_in_cache(true); - block_based_options.set_cache_index_and_filter_blocks(true); - block_based_options.set_bloom_filter(15.5, true); - - // NOTE: As per the rocks db wiki: "The overhead of statistics is usually small but non-negligible. We usually observe an overhead of 5%-10%." - #[cfg(feature = "metrics")] - { - opts.enable_statistics(); - opts.set_statistics_level(rocksdb::statistics::StatsLevel::ExceptTimeForMutex); - } - - if let Some(prefix_len) = prefix_len { - let transform = rocksdb::SliceTransform::create_fixed_prefix(prefix_len); - block_based_options.set_index_type(rocksdb::BlockBasedIndexType::HashSearch); - opts.set_memtable_prefix_bloom_ratio(0.02); - opts.set_prefix_extractor(transform); - } - - if let CacheSetting::Enabled(cache_size) = cache_setting { - let block_cache = Cache::new_lru_cache(cache_size/2); - let row_cache = Cache::new_lru_cache(cache_size/2); - - opts.set_row_cache(&row_cache); - block_based_options.set_block_cache(&block_cache); - } - - match self { - DbConfig::OptimizedPointLookUp => { - block_based_options.set_data_block_hash_ratio(0.75); - block_based_options.set_data_block_index_type(rocksdb::DataBlockIndexType::BinaryAndHash); - opts.set_use_direct_reads(true); - opts.set_memtable_whole_key_filtering(true); - opts.set_compression_type(rocksdb::DBCompressionType::None); - } - DbConfig::Default => { - opts.set_compression_type(rocksdb::DBCompressionType::Lz4); - opts.set_bottommost_compression_type(rocksdb::DBCompressionType::Zstd); - opts.set_bottommost_compression_options(-14, 32767, 0, 16 * 1024, true); // mostly defaults except max_dict_bytes - opts.set_bottommost_zstd_max_train_bytes(1600 * 1024, true); - } - } - - opts.set_block_based_table_factory(&block_based_options); - - opts - } -} diff --git a/benchmark_results/run_20241210_133544/results.json b/benchmark_results/run_20241210_133544/results.json deleted file mode 100644 index 6a87e9644..000000000 --- a/benchmark_results/run_20241210_133544/results.json +++ /dev/null @@ -1,21 +0,0 @@ -{ - "run_id": "bench-3900598631", - "rps_summary": { - "max": 2145.0, - "min": 186.0, - "average": 1137.3015828936407, - "std_dev": 113.07541047229918 - }, - "tps_summary": { - "max": 1505.0, - "min": 29.0, - "average": 1136.8561111111112, - "std_dev": 113.92592313716094 - }, - "revert_summary": { - "max": 0.0, - "min": 0.0, - "average": 0.0, - "std_dev": 0.0 - } -} \ No newline at end of file diff --git a/benchmark_results/run_20241210_155749/config_11_large_prefix_bloom_ratio.rs b/benchmark_results/run_20241210_155749/config_11_large_prefix_bloom_ratio.rs deleted file mode 100644 index 459252751..000000000 --- a/benchmark_results/run_20241210_155749/config_11_large_prefix_bloom_ratio.rs +++ /dev/null @@ -1,80 +0,0 @@ -use rocksdb::BlockBasedOptions; -use rocksdb::Cache; -use rocksdb::Options; - -pub enum CacheSetting { - /// Enabled cache with the given size in bytes - Enabled(usize), - Disabled, -} - -#[derive(Debug, Clone, Copy)] -pub enum DbConfig { - OptimizedPointLookUp, - Default, -} - -impl Default for DbConfig { - fn default() -> Self { - Self::Default - } -} - -impl DbConfig { - pub fn to_options(self, cache_setting: CacheSetting, prefix_len: Option, _key_len: usize) -> Options { - let mut opts = Options::default(); - let mut block_based_options = BlockBasedOptions::default(); - - opts.create_if_missing(true); - opts.create_missing_column_families(true); - opts.increase_parallelism(16); - // add an assertion so that the ulimit -n is at least double this. - // opts.set_max_open_files(40960); - - block_based_options.set_pin_l0_filter_and_index_blocks_in_cache(true); - block_based_options.set_cache_index_and_filter_blocks(true); - block_based_options.set_bloom_filter(15.5, true); - - // NOTE: As per the rocks db wiki: "The overhead of statistics is usually small but non-negligible. We usually observe an overhead of 5%-10%." - #[cfg(feature = "metrics")] - { - opts.enable_statistics(); - opts.set_statistics_level(rocksdb::statistics::StatsLevel::ExceptTimeForMutex); - } - - if let Some(prefix_len) = prefix_len { - let transform = rocksdb::SliceTransform::create_fixed_prefix(prefix_len); - block_based_options.set_index_type(rocksdb::BlockBasedIndexType::HashSearch); - opts.set_memtable_prefix_bloom_ratio(0.25); - opts.set_prefix_extractor(transform); - } - - if let CacheSetting::Enabled(cache_size) = cache_setting { - let block_cache = Cache::new_lru_cache(cache_size/2); - let row_cache = Cache::new_lru_cache(cache_size/2); - - opts.set_row_cache(&row_cache); - block_based_options.set_block_cache(&block_cache); - } - - match self { - DbConfig::OptimizedPointLookUp => { - block_based_options.set_data_block_hash_ratio(0.5); - block_based_options.set_data_block_index_type(rocksdb::DataBlockIndexType::BinaryAndHash); - opts.set_use_direct_reads(true); - opts.set_memtable_whole_key_filtering(true); - opts.set_compression_type(rocksdb::DBCompressionType::None); - } - DbConfig::Default => { - opts.set_compression_type(rocksdb::DBCompressionType::Lz4); - opts.set_bottommost_compression_type(rocksdb::DBCompressionType::Zstd); - opts.set_bottommost_compression_options(-14, 32767, 0, 16 * 1024, true); // mostly defaults except max_dict_bytes - opts.set_bottommost_zstd_max_train_bytes(1600 * 1024, true); - } - } - - opts.set_block_based_table_factory(&block_based_options); - - opts - } -} diff --git a/benchmark_results/run_20241210_155749/results.json b/benchmark_results/run_20241210_155749/results.json deleted file mode 100644 index a9d31be85..000000000 --- a/benchmark_results/run_20241210_155749/results.json +++ /dev/null @@ -1,21 +0,0 @@ -{ - "run_id": "bench-2157164647", - "rps_summary": { - "max": 2423.0, - "min": 144.0, - "average": 1152.7336850874758, - "std_dev": 90.85517618251285 - }, - "tps_summary": { - "max": 1554.0, - "min": 97.0, - "average": 1152.2788888888888, - "std_dev": 89.53461155012698 - }, - "revert_summary": { - "max": 0.0, - "min": 0.0, - "average": 0.0, - "std_dev": 0.0 - } -} \ No newline at end of file diff --git a/benchmark_results/run_20241210_181454/config_12_smaller_block_size.rs b/benchmark_results/run_20241210_181454/config_12_smaller_block_size.rs deleted file mode 100644 index 86777b885..000000000 --- a/benchmark_results/run_20241210_181454/config_12_smaller_block_size.rs +++ /dev/null @@ -1,82 +0,0 @@ -use rocksdb::BlockBasedOptions; -use rocksdb::Cache; -use rocksdb::Options; - -pub enum CacheSetting { - /// Enabled cache with the given size in bytes - Enabled(usize), - Disabled, -} - -#[derive(Debug, Clone, Copy)] -pub enum DbConfig { - OptimizedPointLookUp, - Default, -} - -impl Default for DbConfig { - fn default() -> Self { - Self::Default - } -} - -impl DbConfig { - pub fn to_options(self, cache_setting: CacheSetting, prefix_len: Option, _key_len: usize) -> Options { - let mut opts = Options::default(); - let mut block_based_options = BlockBasedOptions::default(); - - opts.create_if_missing(true); - opts.create_missing_column_families(true); - opts.increase_parallelism(16); - // add an assertion so that the ulimit -n is at least double this. - // opts.set_max_open_files(40960); - - block_based_options.set_pin_l0_filter_and_index_blocks_in_cache(true); - block_based_options.set_cache_index_and_filter_blocks(true); - block_based_options.set_bloom_filter(15.5, true); - - // NOTE: As per the rocks db wiki: "The overhead of statistics is usually small but non-negligible. We usually observe an overhead of 5%-10%." - #[cfg(feature = "metrics")] - { - opts.enable_statistics(); - opts.set_statistics_level(rocksdb::statistics::StatsLevel::ExceptTimeForMutex); - } - - if let Some(prefix_len) = prefix_len { - let transform = rocksdb::SliceTransform::create_fixed_prefix(prefix_len); - block_based_options.set_index_type(rocksdb::BlockBasedIndexType::HashSearch); - opts.set_memtable_prefix_bloom_ratio(0.02); - opts.set_prefix_extractor(transform); - } - - if let CacheSetting::Enabled(cache_size) = cache_setting { - let block_cache = Cache::new_lru_cache(cache_size/2); - let row_cache = Cache::new_lru_cache(cache_size/2); - - opts.set_row_cache(&row_cache); - block_based_options.set_block_cache(&block_cache); - } - - match self { - DbConfig::OptimizedPointLookUp => { - block_based_options.set_data_block_hash_ratio(0.5); - block_based_options.set_data_block_index_type(rocksdb::DataBlockIndexType::BinaryAndHash); - block_based_options.set_block_size(512); - - opts.set_use_direct_reads(true); - opts.set_memtable_whole_key_filtering(true); - opts.set_compression_type(rocksdb::DBCompressionType::None); - } - DbConfig::Default => { - opts.set_compression_type(rocksdb::DBCompressionType::Lz4); - opts.set_bottommost_compression_type(rocksdb::DBCompressionType::Zstd); - opts.set_bottommost_compression_options(-14, 32767, 0, 16 * 1024, true); // mostly defaults except max_dict_bytes - opts.set_bottommost_zstd_max_train_bytes(1600 * 1024, true); - } - } - - opts.set_block_based_table_factory(&block_based_options); - - opts - } -} diff --git a/benchmark_results/run_20241210_181454/results.json b/benchmark_results/run_20241210_181454/results.json deleted file mode 100644 index fb037b922..000000000 --- a/benchmark_results/run_20241210_181454/results.json +++ /dev/null @@ -1,21 +0,0 @@ -{ - "run_id": "bench-589581602", - "rps_summary": { - "max": 2023.0, - "min": 85.0, - "average": 1040.2868647597888, - "std_dev": 79.23441062385747 - }, - "tps_summary": { - "max": 1378.0, - "min": 20.0, - "average": 1039.949986107252, - "std_dev": 79.1373800608478 - }, - "revert_summary": { - "max": 0.0, - "min": 0.0, - "average": 0.0, - "std_dev": 0.0 - } -} \ No newline at end of file diff --git a/benchmark_results/run_20241210_203146/config_13_larger_block_size.rs b/benchmark_results/run_20241210_203146/config_13_larger_block_size.rs deleted file mode 100644 index 8fdc6d6cf..000000000 --- a/benchmark_results/run_20241210_203146/config_13_larger_block_size.rs +++ /dev/null @@ -1,82 +0,0 @@ -use rocksdb::BlockBasedOptions; -use rocksdb::Cache; -use rocksdb::Options; - -pub enum CacheSetting { - /// Enabled cache with the given size in bytes - Enabled(usize), - Disabled, -} - -#[derive(Debug, Clone, Copy)] -pub enum DbConfig { - OptimizedPointLookUp, - Default, -} - -impl Default for DbConfig { - fn default() -> Self { - Self::Default - } -} - -impl DbConfig { - pub fn to_options(self, cache_setting: CacheSetting, prefix_len: Option, _key_len: usize) -> Options { - let mut opts = Options::default(); - let mut block_based_options = BlockBasedOptions::default(); - - opts.create_if_missing(true); - opts.create_missing_column_families(true); - opts.increase_parallelism(16); - // add an assertion so that the ulimit -n is at least double this. - // opts.set_max_open_files(40960); - - block_based_options.set_pin_l0_filter_and_index_blocks_in_cache(true); - block_based_options.set_cache_index_and_filter_blocks(true); - block_based_options.set_bloom_filter(15.5, true); - - // NOTE: As per the rocks db wiki: "The overhead of statistics is usually small but non-negligible. We usually observe an overhead of 5%-10%." - #[cfg(feature = "metrics")] - { - opts.enable_statistics(); - opts.set_statistics_level(rocksdb::statistics::StatsLevel::ExceptTimeForMutex); - } - - if let Some(prefix_len) = prefix_len { - let transform = rocksdb::SliceTransform::create_fixed_prefix(prefix_len); - block_based_options.set_index_type(rocksdb::BlockBasedIndexType::HashSearch); - opts.set_memtable_prefix_bloom_ratio(0.02); - opts.set_prefix_extractor(transform); - } - - if let CacheSetting::Enabled(cache_size) = cache_setting { - let block_cache = Cache::new_lru_cache(cache_size/2); - let row_cache = Cache::new_lru_cache(cache_size/2); - - opts.set_row_cache(&row_cache); - block_based_options.set_block_cache(&block_cache); - } - - match self { - DbConfig::OptimizedPointLookUp => { - block_based_options.set_data_block_hash_ratio(0.5); - block_based_options.set_data_block_index_type(rocksdb::DataBlockIndexType::BinaryAndHash); - block_based_options.set_block_size(1024*32); - - opts.set_use_direct_reads(true); - opts.set_memtable_whole_key_filtering(true); - opts.set_compression_type(rocksdb::DBCompressionType::None); - } - DbConfig::Default => { - opts.set_compression_type(rocksdb::DBCompressionType::Lz4); - opts.set_bottommost_compression_type(rocksdb::DBCompressionType::Zstd); - opts.set_bottommost_compression_options(-14, 32767, 0, 16 * 1024, true); // mostly defaults except max_dict_bytes - opts.set_bottommost_zstd_max_train_bytes(1600 * 1024, true); - } - } - - opts.set_block_based_table_factory(&block_based_options); - - opts - } -} diff --git a/benchmark_results/run_20241210_203146/results.json b/benchmark_results/run_20241210_203146/results.json deleted file mode 100644 index 3926122e0..000000000 --- a/benchmark_results/run_20241210_203146/results.json +++ /dev/null @@ -1,21 +0,0 @@ -{ - "run_id": "bench-3474106885", - "rps_summary": { - "max": 2130.0, - "min": 158.0, - "average": 1020.2227159122466, - "std_dev": 73.48604021575916 - }, - "tps_summary": { - "max": 1339.0, - "min": 41.0, - "average": 1019.7761111111112, - "std_dev": 72.55423171967362 - }, - "revert_summary": { - "max": 0.0, - "min": 0.0, - "average": 0.0, - "std_dev": 0.0 - } -} \ No newline at end of file diff --git a/benchmark_results/run_20241210_225602/config_14_HyperClockCache.rs b/benchmark_results/run_20241210_225602/config_14_HyperClockCache.rs deleted file mode 100644 index 6bc4cde08..000000000 --- a/benchmark_results/run_20241210_225602/config_14_HyperClockCache.rs +++ /dev/null @@ -1,81 +0,0 @@ -use rocksdb::BlockBasedOptions; -use rocksdb::Cache; -use rocksdb::Options; - -pub enum CacheSetting { - /// Enabled cache with the given size in bytes - Enabled(usize), - Disabled, -} - -#[derive(Debug, Clone, Copy)] -pub enum DbConfig { - OptimizedPointLookUp, - Default, -} - -impl Default for DbConfig { - fn default() -> Self { - Self::Default - } -} - -impl DbConfig { - pub fn to_options(self, cache_setting: CacheSetting, prefix_len: Option, _key_len: usize) -> Options { - let mut opts = Options::default(); - let mut block_based_options = BlockBasedOptions::default(); - - opts.create_if_missing(true); - opts.create_missing_column_families(true); - opts.increase_parallelism(16); - // add an assertion so that the ulimit -n is at least double this. - // opts.set_max_open_files(40960); - - block_based_options.set_pin_l0_filter_and_index_blocks_in_cache(true); - block_based_options.set_cache_index_and_filter_blocks(true); - block_based_options.set_bloom_filter(15.5, true); - - // NOTE: As per the rocks db wiki: "The overhead of statistics is usually small but non-negligible. We usually observe an overhead of 5%-10%." - #[cfg(feature = "metrics")] - { - opts.enable_statistics(); - opts.set_statistics_level(rocksdb::statistics::StatsLevel::ExceptTimeForMutex); - } - - if let Some(prefix_len) = prefix_len { - let transform = rocksdb::SliceTransform::create_fixed_prefix(prefix_len); - block_based_options.set_index_type(rocksdb::BlockBasedIndexType::HashSearch); - opts.set_memtable_prefix_bloom_ratio(0.02); - opts.set_prefix_extractor(transform); - } - - if let CacheSetting::Enabled(cache_size) = cache_setting { - // the documentation states that passing 0 to the estimated entry charge makes it so rocks estimates a good value - let block_cache = Cache::new_hyper_clock_cache(cache_size/2, 0); - let row_cache = Cache::new_hyper_clock_cache(cache_size/2, 0); - - opts.set_row_cache(&row_cache); - block_based_options.set_block_cache(&block_cache); - } - - match self { - DbConfig::OptimizedPointLookUp => { - block_based_options.set_data_block_hash_ratio(0.5); - block_based_options.set_data_block_index_type(rocksdb::DataBlockIndexType::BinaryAndHash); - opts.set_use_direct_reads(true); - opts.set_memtable_whole_key_filtering(true); - opts.set_compression_type(rocksdb::DBCompressionType::None); - } - DbConfig::Default => { - opts.set_compression_type(rocksdb::DBCompressionType::Lz4); - opts.set_bottommost_compression_type(rocksdb::DBCompressionType::Zstd); - opts.set_bottommost_compression_options(-14, 32767, 0, 16 * 1024, true); // mostly defaults except max_dict_bytes - opts.set_bottommost_zstd_max_train_bytes(1600 * 1024, true); - } - } - - opts.set_block_based_table_factory(&block_based_options); - - opts - } -} diff --git a/benchmark_results/run_20241210_225602/results.json b/benchmark_results/run_20241210_225602/results.json deleted file mode 100644 index 6eac5ca9e..000000000 --- a/benchmark_results/run_20241210_225602/results.json +++ /dev/null @@ -1,21 +0,0 @@ -{ - "run_id": "bench-3473214436", - "rps_summary": { - "max": 2410.0, - "min": 170.0, - "average": 1253.939461260761, - "std_dev": 97.94741659876098 - }, - "tps_summary": { - "max": 1709.0, - "min": 76.0, - "average": 1253.4541666666667, - "std_dev": 97.54129102519151 - }, - "revert_summary": { - "max": 0.0, - "min": 0.0, - "average": 0.0, - "std_dev": 0.0 - } -} \ No newline at end of file diff --git a/benchmark_results/run_20241211_173935/config_15_Final_01.rs b/benchmark_results/run_20241211_173935/config_15_Final_01.rs deleted file mode 100644 index ba7a77fb5..000000000 --- a/benchmark_results/run_20241211_173935/config_15_Final_01.rs +++ /dev/null @@ -1,79 +0,0 @@ -use rocksdb::BlockBasedOptions; -use rocksdb::Cache; -use rocksdb::Options; - -pub enum CacheSetting { - /// Enabled cache with the given size in bytes - Enabled(usize), - Disabled, -} - -#[derive(Debug, Clone, Copy)] -pub enum DbConfig { - OptimizedPointLookUp, - Default, -} - -impl Default for DbConfig { - fn default() -> Self { - Self::Default - } -} - -impl DbConfig { - pub fn to_options(self, cache_setting: CacheSetting, prefix_len: Option, _key_len: usize) -> Options { - let mut opts = Options::default(); - let mut block_based_options = BlockBasedOptions::default(); - - opts.create_if_missing(true); - opts.create_missing_column_families(true); - opts.increase_parallelism(16); - - block_based_options.set_pin_l0_filter_and_index_blocks_in_cache(true); - block_based_options.set_cache_index_and_filter_blocks(true); - block_based_options.set_bloom_filter(15.5, true); - - // NOTE: As per the rocks db wiki: "The overhead of statistics is usually small but non-negligible. We usually observe an overhead of 5%-10%." - #[cfg(feature = "metrics")] - { - opts.enable_statistics(); - opts.set_statistics_level(rocksdb::statistics::StatsLevel::ExceptTimeForMutex); - } - - if let Some(prefix_len) = prefix_len { - let transform = rocksdb::SliceTransform::create_fixed_prefix(prefix_len); - block_based_options.set_index_type(rocksdb::BlockBasedIndexType::HashSearch); - opts.set_memtable_prefix_bloom_ratio(0.15); - opts.set_prefix_extractor(transform); - } - - if let CacheSetting::Enabled(cache_size) = cache_setting { - let block_cache = Cache::new_hyper_clock_cache(cache_size/2, 0); - let row_cache = Cache::new_hyper_clock_cache(cache_size/2, 0); - - opts.set_row_cache(&row_cache); - block_based_options.set_block_cache(&block_cache); - } - - match self { - DbConfig::OptimizedPointLookUp => { - block_based_options.set_data_block_hash_ratio(0.3); - block_based_options.set_data_block_index_type(rocksdb::DataBlockIndexType::BinaryAndHash); - - opts.set_use_direct_reads(true); - opts.set_memtable_whole_key_filtering(true); - opts.set_compression_type(rocksdb::DBCompressionType::None); - } - DbConfig::Default => { - opts.set_compression_type(rocksdb::DBCompressionType::Lz4); - opts.set_bottommost_compression_type(rocksdb::DBCompressionType::Zstd); - opts.set_bottommost_compression_options(-14, 32767, 0, 16 * 1024, true); // mostly defaults except max_dict_bytes - opts.set_bottommost_zstd_max_train_bytes(1600 * 1024, true); - } - } - - opts.set_block_based_table_factory(&block_based_options); - - opts - } -} diff --git a/benchmark_results/run_20241211_173935/results.json b/benchmark_results/run_20241211_173935/results.json deleted file mode 100644 index fd9621296..000000000 --- a/benchmark_results/run_20241211_173935/results.json +++ /dev/null @@ -1,21 +0,0 @@ -{ - "run_id": "bench-3068965515", - "rps_summary": { - "max": 2181.0, - "min": 220.0, - "average": 1113.7311857817274, - "std_dev": 138.41321746562141 - }, - "tps_summary": { - "max": 1484.0, - "min": 8.0, - "average": 1113.1775, - "std_dev": 139.22684485070855 - }, - "revert_summary": { - "max": 0.0, - "min": 0.0, - "average": 0.0, - "std_dev": 0.0 - } -} \ No newline at end of file diff --git a/benchmark_results/run_20241211_200203/config_16_Final_02.rs b/benchmark_results/run_20241211_200203/config_16_Final_02.rs deleted file mode 100644 index d6e3d63b5..000000000 --- a/benchmark_results/run_20241211_200203/config_16_Final_02.rs +++ /dev/null @@ -1,79 +0,0 @@ -use rocksdb::BlockBasedOptions; -use rocksdb::Cache; -use rocksdb::Options; - -pub enum CacheSetting { - /// Enabled cache with the given size in bytes - Enabled(usize), - Disabled, -} - -#[derive(Debug, Clone, Copy)] -pub enum DbConfig { - OptimizedPointLookUp, - Default, -} - -impl Default for DbConfig { - fn default() -> Self { - Self::Default - } -} - -impl DbConfig { - pub fn to_options(self, cache_setting: CacheSetting, prefix_len: Option, _key_len: usize) -> Options { - let mut opts = Options::default(); - let mut block_based_options = BlockBasedOptions::default(); - - opts.create_if_missing(true); - opts.create_missing_column_families(true); - opts.increase_parallelism(16); - - block_based_options.set_pin_l0_filter_and_index_blocks_in_cache(true); - block_based_options.set_cache_index_and_filter_blocks(true); - block_based_options.set_bloom_filter(15.5, true); - - // NOTE: As per the rocks db wiki: "The overhead of statistics is usually small but non-negligible. We usually observe an overhead of 5%-10%." - #[cfg(feature = "metrics")] - { - opts.enable_statistics(); - opts.set_statistics_level(rocksdb::statistics::StatsLevel::ExceptTimeForMutex); - } - - if let Some(prefix_len) = prefix_len { - let transform = rocksdb::SliceTransform::create_fixed_prefix(prefix_len); - block_based_options.set_index_type(rocksdb::BlockBasedIndexType::HashSearch); - opts.set_memtable_prefix_bloom_ratio(0.15); - opts.set_prefix_extractor(transform); - } - - if let CacheSetting::Enabled(cache_size) = cache_setting { - let block_cache = Cache::new_lru_cache(cache_size/2); - let row_cache = Cache::new_lru_cache(cache_size/2); - - opts.set_row_cache(&row_cache); - block_based_options.set_block_cache(&block_cache); - } - - match self { - DbConfig::OptimizedPointLookUp => { - block_based_options.set_data_block_hash_ratio(0.3); - block_based_options.set_data_block_index_type(rocksdb::DataBlockIndexType::BinaryAndHash); - - opts.set_use_direct_reads(true); - opts.set_memtable_whole_key_filtering(true); - opts.set_compression_type(rocksdb::DBCompressionType::None); - } - DbConfig::Default => { - opts.set_compression_type(rocksdb::DBCompressionType::Lz4); - opts.set_bottommost_compression_type(rocksdb::DBCompressionType::Zstd); - opts.set_bottommost_compression_options(-14, 32767, 0, 16 * 1024, true); // mostly defaults except max_dict_bytes - opts.set_bottommost_zstd_max_train_bytes(1600 * 1024, true); - } - } - - opts.set_block_based_table_factory(&block_based_options); - - opts - } -} diff --git a/benchmark_results/run_20241211_200203/results.json b/benchmark_results/run_20241211_200203/results.json deleted file mode 100644 index 3b29cb4d6..000000000 --- a/benchmark_results/run_20241211_200203/results.json +++ /dev/null @@ -1,21 +0,0 @@ -{ - "run_id": "bench-1677678025", - "rps_summary": { - "max": 2314.0, - "min": 214.0, - "average": 1107.2738128297694, - "std_dev": 141.65601880855704 - }, - "tps_summary": { - "max": 1496.0, - "min": 125.0, - "average": 1106.8444444444444, - "std_dev": 143.5400475369632 - }, - "revert_summary": { - "max": 0.0, - "min": 0.0, - "average": 0.0, - "std_dev": 0.0 - } -} \ No newline at end of file diff --git a/benchmark_results/run_20241211_222611/config_17_Final_03.rs b/benchmark_results/run_20241211_222611/config_17_Final_03.rs deleted file mode 100644 index 0dd61b2e2..000000000 --- a/benchmark_results/run_20241211_222611/config_17_Final_03.rs +++ /dev/null @@ -1,79 +0,0 @@ -use rocksdb::BlockBasedOptions; -use rocksdb::Cache; -use rocksdb::Options; - -pub enum CacheSetting { - /// Enabled cache with the given size in bytes - Enabled(usize), - Disabled, -} - -#[derive(Debug, Clone, Copy)] -pub enum DbConfig { - OptimizedPointLookUp, - Default, -} - -impl Default for DbConfig { - fn default() -> Self { - Self::Default - } -} - -impl DbConfig { - pub fn to_options(self, cache_setting: CacheSetting, prefix_len: Option, _key_len: usize) -> Options { - let mut opts = Options::default(); - let mut block_based_options = BlockBasedOptions::default(); - - opts.create_if_missing(true); - opts.create_missing_column_families(true); - opts.increase_parallelism(16); - - block_based_options.set_pin_l0_filter_and_index_blocks_in_cache(true); - block_based_options.set_cache_index_and_filter_blocks(true); - block_based_options.set_bloom_filter(15.5, false); - - // NOTE: As per the rocks db wiki: "The overhead of statistics is usually small but non-negligible. We usually observe an overhead of 5%-10%." - #[cfg(feature = "metrics")] - { - opts.enable_statistics(); - opts.set_statistics_level(rocksdb::statistics::StatsLevel::ExceptTimeForMutex); - } - - if let Some(prefix_len) = prefix_len { - let transform = rocksdb::SliceTransform::create_fixed_prefix(prefix_len); - block_based_options.set_index_type(rocksdb::BlockBasedIndexType::HashSearch); - opts.set_memtable_prefix_bloom_ratio(0.15); - opts.set_prefix_extractor(transform); - } - - if let CacheSetting::Enabled(cache_size) = cache_setting { - let block_cache = Cache::new_lru_cache(cache_size/2); - let row_cache = Cache::new_lru_cache(cache_size/2); - - opts.set_row_cache(&row_cache); - block_based_options.set_block_cache(&block_cache); - } - - match self { - DbConfig::OptimizedPointLookUp => { - block_based_options.set_data_block_hash_ratio(0.3); - block_based_options.set_data_block_index_type(rocksdb::DataBlockIndexType::BinaryAndHash); - - opts.set_use_direct_reads(true); - opts.set_memtable_whole_key_filtering(true); - opts.set_compression_type(rocksdb::DBCompressionType::None); - } - DbConfig::Default => { - opts.set_compression_type(rocksdb::DBCompressionType::Lz4); - opts.set_bottommost_compression_type(rocksdb::DBCompressionType::Zstd); - opts.set_bottommost_compression_options(-14, 32767, 0, 16 * 1024, true); // mostly defaults except max_dict_bytes - opts.set_bottommost_zstd_max_train_bytes(1600 * 1024, true); - } - } - - opts.set_block_based_table_factory(&block_based_options); - - opts - } -} diff --git a/benchmark_results/run_20241211_222611/results.json b/benchmark_results/run_20241211_222611/results.json deleted file mode 100644 index 9680e627b..000000000 --- a/benchmark_results/run_20241211_222611/results.json +++ /dev/null @@ -1,21 +0,0 @@ -{ - "run_id": "bench-16793164", - "rps_summary": { - "max": 2378.0, - "min": 79.0, - "average": 1151.5373507359068, - "std_dev": 140.0899810276136 - }, - "tps_summary": { - "max": 1540.0, - "min": 375.0, - "average": 1151.2550708530148, - "std_dev": 138.06868339736235 - }, - "revert_summary": { - "max": 0.0, - "min": 0.0, - "average": 0.0, - "std_dev": 0.0 - } -} \ No newline at end of file diff --git a/benchmark_results/run_20241212_145714/config_15_Final_01.rs b/benchmark_results/run_20241212_145714/config_15_Final_01.rs deleted file mode 100644 index ba7a77fb5..000000000 --- a/benchmark_results/run_20241212_145714/config_15_Final_01.rs +++ /dev/null @@ -1,79 +0,0 @@ -use rocksdb::BlockBasedOptions; -use rocksdb::Cache; -use rocksdb::Options; - -pub enum CacheSetting { - /// Enabled cache with the given size in bytes - Enabled(usize), - Disabled, -} - -#[derive(Debug, Clone, Copy)] -pub enum DbConfig { - OptimizedPointLookUp, - Default, -} - -impl Default for DbConfig { - fn default() -> Self { - Self::Default - } -} - -impl DbConfig { - pub fn to_options(self, cache_setting: CacheSetting, prefix_len: Option, _key_len: usize) -> Options { - let mut opts = Options::default(); - let mut block_based_options = BlockBasedOptions::default(); - - opts.create_if_missing(true); - opts.create_missing_column_families(true); - opts.increase_parallelism(16); - - block_based_options.set_pin_l0_filter_and_index_blocks_in_cache(true); - block_based_options.set_cache_index_and_filter_blocks(true); - block_based_options.set_bloom_filter(15.5, true); - - // NOTE: As per the rocks db wiki: "The overhead of statistics is usually small but non-negligible. We usually observe an overhead of 5%-10%." - #[cfg(feature = "metrics")] - { - opts.enable_statistics(); - opts.set_statistics_level(rocksdb::statistics::StatsLevel::ExceptTimeForMutex); - } - - if let Some(prefix_len) = prefix_len { - let transform = rocksdb::SliceTransform::create_fixed_prefix(prefix_len); - block_based_options.set_index_type(rocksdb::BlockBasedIndexType::HashSearch); - opts.set_memtable_prefix_bloom_ratio(0.15); - opts.set_prefix_extractor(transform); - } - - if let CacheSetting::Enabled(cache_size) = cache_setting { - let block_cache = Cache::new_hyper_clock_cache(cache_size/2, 0); - let row_cache = Cache::new_hyper_clock_cache(cache_size/2, 0); - - opts.set_row_cache(&row_cache); - block_based_options.set_block_cache(&block_cache); - } - - match self { - DbConfig::OptimizedPointLookUp => { - block_based_options.set_data_block_hash_ratio(0.3); - block_based_options.set_data_block_index_type(rocksdb::DataBlockIndexType::BinaryAndHash); - - opts.set_use_direct_reads(true); - opts.set_memtable_whole_key_filtering(true); - opts.set_compression_type(rocksdb::DBCompressionType::None); - } - DbConfig::Default => { - opts.set_compression_type(rocksdb::DBCompressionType::Lz4); - opts.set_bottommost_compression_type(rocksdb::DBCompressionType::Zstd); - opts.set_bottommost_compression_options(-14, 32767, 0, 16 * 1024, true); // mostly defaults except max_dict_bytes - opts.set_bottommost_zstd_max_train_bytes(1600 * 1024, true); - } - } - - opts.set_block_based_table_factory(&block_based_options); - - opts - } -} diff --git a/benchmark_results/run_20241212_145714/results.json b/benchmark_results/run_20241212_145714/results.json deleted file mode 100644 index 6707a8ca9..000000000 --- a/benchmark_results/run_20241212_145714/results.json +++ /dev/null @@ -1,21 +0,0 @@ -{ - "run_id": "bench-1460364515", - "rps_summary": { - "max": 2144.0, - "min": 246.0, - "average": 1112.332963065815, - "std_dev": 141.39910033474266 - }, - "tps_summary": { - "max": 1521.0, - "min": 11.0, - "average": 1111.8177777777778, - "std_dev": 142.49798484171836 - }, - "revert_summary": { - "max": 0.0, - "min": 0.0, - "average": 0.0, - "std_dev": 0.0 - } -} \ No newline at end of file diff --git a/benchmark_results/run_20241212_171851/config_16_Final_02.rs b/benchmark_results/run_20241212_171851/config_16_Final_02.rs deleted file mode 100644 index d6e3d63b5..000000000 --- a/benchmark_results/run_20241212_171851/config_16_Final_02.rs +++ /dev/null @@ -1,79 +0,0 @@ -use rocksdb::BlockBasedOptions; -use rocksdb::Cache; -use rocksdb::Options; - -pub enum CacheSetting { - /// Enabled cache with the given size in bytes - Enabled(usize), - Disabled, -} - -#[derive(Debug, Clone, Copy)] -pub enum DbConfig { - OptimizedPointLookUp, - Default, -} - -impl Default for DbConfig { - fn default() -> Self { - Self::Default - } -} - -impl DbConfig { - pub fn to_options(self, cache_setting: CacheSetting, prefix_len: Option, _key_len: usize) -> Options { - let mut opts = Options::default(); - let mut block_based_options = BlockBasedOptions::default(); - - opts.create_if_missing(true); - opts.create_missing_column_families(true); - opts.increase_parallelism(16); - - block_based_options.set_pin_l0_filter_and_index_blocks_in_cache(true); - block_based_options.set_cache_index_and_filter_blocks(true); - block_based_options.set_bloom_filter(15.5, true); - - // NOTE: As per the rocks db wiki: "The overhead of statistics is usually small but non-negligible. We usually observe an overhead of 5%-10%." - #[cfg(feature = "metrics")] - { - opts.enable_statistics(); - opts.set_statistics_level(rocksdb::statistics::StatsLevel::ExceptTimeForMutex); - } - - if let Some(prefix_len) = prefix_len { - let transform = rocksdb::SliceTransform::create_fixed_prefix(prefix_len); - block_based_options.set_index_type(rocksdb::BlockBasedIndexType::HashSearch); - opts.set_memtable_prefix_bloom_ratio(0.15); - opts.set_prefix_extractor(transform); - } - - if let CacheSetting::Enabled(cache_size) = cache_setting { - let block_cache = Cache::new_lru_cache(cache_size/2); - let row_cache = Cache::new_lru_cache(cache_size/2); - - opts.set_row_cache(&row_cache); - block_based_options.set_block_cache(&block_cache); - } - - match self { - DbConfig::OptimizedPointLookUp => { - block_based_options.set_data_block_hash_ratio(0.3); - block_based_options.set_data_block_index_type(rocksdb::DataBlockIndexType::BinaryAndHash); - - opts.set_use_direct_reads(true); - opts.set_memtable_whole_key_filtering(true); - opts.set_compression_type(rocksdb::DBCompressionType::None); - } - DbConfig::Default => { - opts.set_compression_type(rocksdb::DBCompressionType::Lz4); - opts.set_bottommost_compression_type(rocksdb::DBCompressionType::Zstd); - opts.set_bottommost_compression_options(-14, 32767, 0, 16 * 1024, true); // mostly defaults except max_dict_bytes - opts.set_bottommost_zstd_max_train_bytes(1600 * 1024, true); - } - } - - opts.set_block_based_table_factory(&block_based_options); - - opts - } -} diff --git a/benchmark_results/run_20241212_171851/results.json b/benchmark_results/run_20241212_171851/results.json deleted file mode 100644 index c6d37e444..000000000 --- a/benchmark_results/run_20241212_171851/results.json +++ /dev/null @@ -1,21 +0,0 @@ -{ - "run_id": "bench-2765341515", - "rps_summary": { - "max": 2173.0, - "min": 283.0, - "average": 1092.098028325465, - "std_dev": 149.8372980381255 - }, - "tps_summary": { - "max": 1517.0, - "min": 21.0, - "average": 1091.5625, - "std_dev": 150.67839550356175 - }, - "revert_summary": { - "max": 0.0, - "min": 0.0, - "average": 0.0, - "std_dev": 0.0 - } -} \ No newline at end of file diff --git a/benchmark_results/run_20241212_194101/config_17_Final_03.rs b/benchmark_results/run_20241212_194101/config_17_Final_03.rs deleted file mode 100644 index 0dd61b2e2..000000000 --- a/benchmark_results/run_20241212_194101/config_17_Final_03.rs +++ /dev/null @@ -1,79 +0,0 @@ -use rocksdb::BlockBasedOptions; -use rocksdb::Cache; -use rocksdb::Options; - -pub enum CacheSetting { - /// Enabled cache with the given size in bytes - Enabled(usize), - Disabled, -} - -#[derive(Debug, Clone, Copy)] -pub enum DbConfig { - OptimizedPointLookUp, - Default, -} - -impl Default for DbConfig { - fn default() -> Self { - Self::Default - } -} - -impl DbConfig { - pub fn to_options(self, cache_setting: CacheSetting, prefix_len: Option, _key_len: usize) -> Options { - let mut opts = Options::default(); - let mut block_based_options = BlockBasedOptions::default(); - - opts.create_if_missing(true); - opts.create_missing_column_families(true); - opts.increase_parallelism(16); - - block_based_options.set_pin_l0_filter_and_index_blocks_in_cache(true); - block_based_options.set_cache_index_and_filter_blocks(true); - block_based_options.set_bloom_filter(15.5, false); - - // NOTE: As per the rocks db wiki: "The overhead of statistics is usually small but non-negligible. We usually observe an overhead of 5%-10%." - #[cfg(feature = "metrics")] - { - opts.enable_statistics(); - opts.set_statistics_level(rocksdb::statistics::StatsLevel::ExceptTimeForMutex); - } - - if let Some(prefix_len) = prefix_len { - let transform = rocksdb::SliceTransform::create_fixed_prefix(prefix_len); - block_based_options.set_index_type(rocksdb::BlockBasedIndexType::HashSearch); - opts.set_memtable_prefix_bloom_ratio(0.15); - opts.set_prefix_extractor(transform); - } - - if let CacheSetting::Enabled(cache_size) = cache_setting { - let block_cache = Cache::new_lru_cache(cache_size/2); - let row_cache = Cache::new_lru_cache(cache_size/2); - - opts.set_row_cache(&row_cache); - block_based_options.set_block_cache(&block_cache); - } - - match self { - DbConfig::OptimizedPointLookUp => { - block_based_options.set_data_block_hash_ratio(0.3); - block_based_options.set_data_block_index_type(rocksdb::DataBlockIndexType::BinaryAndHash); - - opts.set_use_direct_reads(true); - opts.set_memtable_whole_key_filtering(true); - opts.set_compression_type(rocksdb::DBCompressionType::None); - } - DbConfig::Default => { - opts.set_compression_type(rocksdb::DBCompressionType::Lz4); - opts.set_bottommost_compression_type(rocksdb::DBCompressionType::Zstd); - opts.set_bottommost_compression_options(-14, 32767, 0, 16 * 1024, true); // mostly defaults except max_dict_bytes - opts.set_bottommost_zstd_max_train_bytes(1600 * 1024, true); - } - } - - opts.set_block_based_table_factory(&block_based_options); - - opts - } -} diff --git a/benchmark_results/run_20241212_194101/results.json b/benchmark_results/run_20241212_194101/results.json deleted file mode 100644 index a5f6a0ab2..000000000 --- a/benchmark_results/run_20241212_194101/results.json +++ /dev/null @@ -1,21 +0,0 @@ -{ - "run_id": "bench-1989751145", - "rps_summary": { - "max": 2168.0, - "min": 57.0, - "average": 1126.8525409608442, - "std_dev": 152.4482282220594 - }, - "tps_summary": { - "max": 1552.0, - "min": 86.0, - "average": 1126.4752777777778, - "std_dev": 154.96139823958504 - }, - "revert_summary": { - "max": 0.0, - "min": 0.0, - "average": 0.0, - "std_dev": 0.0 - } -} \ No newline at end of file diff --git a/benchmark_results/run_20241213_152709/config_15_Final_01.rs b/benchmark_results/run_20241213_152709/config_15_Final_01.rs deleted file mode 100644 index 7050f86a2..000000000 --- a/benchmark_results/run_20241213_152709/config_15_Final_01.rs +++ /dev/null @@ -1,72 +0,0 @@ -use rocksdb::BlockBasedOptions; -use rocksdb::Cache; -use rocksdb::Options; - -pub enum CacheSetting { - /// Enabled cache with the given size in bytes - Enabled(usize), - Disabled, -} - -#[derive(Debug, Clone, Copy)] -pub enum DbConfig { - OptimizedPointLookUp, - Default, -} - -impl Default for DbConfig { - fn default() -> Self { - Self::Default - } -} - -impl DbConfig { - pub fn to_options(self, cache_setting: CacheSetting, prefix_len: Option, _key_len: usize) -> Options { - let mut opts = Options::default(); - let mut block_based_options = BlockBasedOptions::default(); - - opts.create_if_missing(true); - opts.create_missing_column_families(true); - opts.increase_parallelism(16); - - block_based_options.set_pin_l0_filter_and_index_blocks_in_cache(true); - block_based_options.set_cache_index_and_filter_blocks(true); - block_based_options.set_bloom_filter(15.5, false); - - if let Some(prefix_len) = prefix_len { - let transform = rocksdb::SliceTransform::create_fixed_prefix(prefix_len); - block_based_options.set_index_type(rocksdb::BlockBasedIndexType::HashSearch); - opts.set_memtable_prefix_bloom_ratio(0.15); - opts.set_prefix_extractor(transform); - } - - if let CacheSetting::Enabled(cache_size) = cache_setting { - let block_cache = Cache::new_hyper_clock_cache(cache_size/2, 0); - let row_cache = Cache::new_hyper_clock_cache(cache_size/2, 0); - - opts.set_row_cache(&row_cache); - block_based_options.set_block_cache(&block_cache); - } - - match self { - DbConfig::OptimizedPointLookUp => { - block_based_options.set_data_block_hash_ratio(0.3); - block_based_options.set_data_block_index_type(rocksdb::DataBlockIndexType::BinaryAndHash); - - opts.set_use_direct_reads(true); - opts.set_memtable_whole_key_filtering(true); - opts.set_compression_type(rocksdb::DBCompressionType::None); - } - DbConfig::Default => { - opts.set_compression_type(rocksdb::DBCompressionType::Lz4); - opts.set_bottommost_compression_type(rocksdb::DBCompressionType::Zstd); - opts.set_bottommost_compression_options(-14, 32767, 0, 16 * 1024, true); // mostly defaults except max_dict_bytes - opts.set_bottommost_zstd_max_train_bytes(1600 * 1024, true); - } - } - - opts.set_block_based_table_factory(&block_based_options); - - opts - } -} diff --git a/benchmark_results/run_20241213_152709/results.json b/benchmark_results/run_20241213_152709/results.json deleted file mode 100644 index d79dc457c..000000000 --- a/benchmark_results/run_20241213_152709/results.json +++ /dev/null @@ -1,21 +0,0 @@ -{ - "run_id": "bench-540218589", - "rps_summary": { - "max": 2348.0, - "min": 250.0, - "average": 1250.3687864482088, - "std_dev": 75.40957728603468 - }, - "tps_summary": { - "max": 1464.0, - "min": 28.0, - "average": 1249.8058333333333, - "std_dev": 75.57649046109961 - }, - "revert_summary": { - "max": 0.0, - "min": 0.0, - "average": 0.0, - "std_dev": 0.0 - } -} \ No newline at end of file diff --git a/benchmark_results/run_20241213_174152/config_16_Final_02.rs b/benchmark_results/run_20241213_174152/config_16_Final_02.rs deleted file mode 100644 index e2b5995c7..000000000 --- a/benchmark_results/run_20241213_174152/config_16_Final_02.rs +++ /dev/null @@ -1,72 +0,0 @@ -use rocksdb::BlockBasedOptions; -use rocksdb::Cache; -use rocksdb::Options; - -pub enum CacheSetting { - /// Enabled cache with the given size in bytes - Enabled(usize), - Disabled, -} - -#[derive(Debug, Clone, Copy)] -pub enum DbConfig { - OptimizedPointLookUp, - Default, -} - -impl Default for DbConfig { - fn default() -> Self { - Self::Default - } -} - -impl DbConfig { - pub fn to_options(self, cache_setting: CacheSetting, prefix_len: Option, _key_len: usize) -> Options { - let mut opts = Options::default(); - let mut block_based_options = BlockBasedOptions::default(); - - opts.create_if_missing(true); - opts.create_missing_column_families(true); - opts.increase_parallelism(16); - - block_based_options.set_pin_l0_filter_and_index_blocks_in_cache(true); - block_based_options.set_cache_index_and_filter_blocks(true); - block_based_options.set_bloom_filter(15.5, false); - - if let Some(prefix_len) = prefix_len { - let transform = rocksdb::SliceTransform::create_fixed_prefix(prefix_len); - block_based_options.set_index_type(rocksdb::BlockBasedIndexType::HashSearch); - opts.set_memtable_prefix_bloom_ratio(0.15); - opts.set_prefix_extractor(transform); - } - - if let CacheSetting::Enabled(cache_size) = cache_setting { - let block_cache = Cache::new_lru_cache(cache_size/2); - let row_cache = Cache::new_lru_cache(cache_size/2); - - opts.set_row_cache(&row_cache); - block_based_options.set_block_cache(&block_cache); - } - - match self { - DbConfig::OptimizedPointLookUp => { - block_based_options.set_data_block_hash_ratio(0.3); - block_based_options.set_data_block_index_type(rocksdb::DataBlockIndexType::BinaryAndHash); - - opts.set_use_direct_reads(true); - opts.set_memtable_whole_key_filtering(true); - opts.set_compression_type(rocksdb::DBCompressionType::None); - } - DbConfig::Default => { - opts.set_compression_type(rocksdb::DBCompressionType::Lz4); - opts.set_bottommost_compression_type(rocksdb::DBCompressionType::Zstd); - opts.set_bottommost_compression_options(-14, 32767, 0, 16 * 1024, true); // mostly defaults except max_dict_bytes - opts.set_bottommost_zstd_max_train_bytes(1600 * 1024, true); - } - } - - opts.set_block_based_table_factory(&block_based_options); - - opts - } -} diff --git a/benchmark_results/run_20241213_174152/results.json b/benchmark_results/run_20241213_174152/results.json deleted file mode 100644 index c523874b9..000000000 --- a/benchmark_results/run_20241213_174152/results.json +++ /dev/null @@ -1,21 +0,0 @@ -{ - "run_id": "bench-3559769409", - "rps_summary": { - "max": 2242.0, - "min": 223.0, - "average": 1271.950013885032, - "std_dev": 71.79240298204985 - }, - "tps_summary": { - "max": 1461.0, - "min": 186.0, - "average": 1271.6218393998333, - "std_dev": 71.73911226654667 - }, - "revert_summary": { - "max": 0.0, - "min": 0.0, - "average": 0.0, - "std_dev": 0.0 - } -} \ No newline at end of file diff --git a/benchmark_results/run_20241213_195732/config_17_Final_03.rs b/benchmark_results/run_20241213_195732/config_17_Final_03.rs deleted file mode 100644 index e2b5995c7..000000000 --- a/benchmark_results/run_20241213_195732/config_17_Final_03.rs +++ /dev/null @@ -1,72 +0,0 @@ -use rocksdb::BlockBasedOptions; -use rocksdb::Cache; -use rocksdb::Options; - -pub enum CacheSetting { - /// Enabled cache with the given size in bytes - Enabled(usize), - Disabled, -} - -#[derive(Debug, Clone, Copy)] -pub enum DbConfig { - OptimizedPointLookUp, - Default, -} - -impl Default for DbConfig { - fn default() -> Self { - Self::Default - } -} - -impl DbConfig { - pub fn to_options(self, cache_setting: CacheSetting, prefix_len: Option, _key_len: usize) -> Options { - let mut opts = Options::default(); - let mut block_based_options = BlockBasedOptions::default(); - - opts.create_if_missing(true); - opts.create_missing_column_families(true); - opts.increase_parallelism(16); - - block_based_options.set_pin_l0_filter_and_index_blocks_in_cache(true); - block_based_options.set_cache_index_and_filter_blocks(true); - block_based_options.set_bloom_filter(15.5, false); - - if let Some(prefix_len) = prefix_len { - let transform = rocksdb::SliceTransform::create_fixed_prefix(prefix_len); - block_based_options.set_index_type(rocksdb::BlockBasedIndexType::HashSearch); - opts.set_memtable_prefix_bloom_ratio(0.15); - opts.set_prefix_extractor(transform); - } - - if let CacheSetting::Enabled(cache_size) = cache_setting { - let block_cache = Cache::new_lru_cache(cache_size/2); - let row_cache = Cache::new_lru_cache(cache_size/2); - - opts.set_row_cache(&row_cache); - block_based_options.set_block_cache(&block_cache); - } - - match self { - DbConfig::OptimizedPointLookUp => { - block_based_options.set_data_block_hash_ratio(0.3); - block_based_options.set_data_block_index_type(rocksdb::DataBlockIndexType::BinaryAndHash); - - opts.set_use_direct_reads(true); - opts.set_memtable_whole_key_filtering(true); - opts.set_compression_type(rocksdb::DBCompressionType::None); - } - DbConfig::Default => { - opts.set_compression_type(rocksdb::DBCompressionType::Lz4); - opts.set_bottommost_compression_type(rocksdb::DBCompressionType::Zstd); - opts.set_bottommost_compression_options(-14, 32767, 0, 16 * 1024, true); // mostly defaults except max_dict_bytes - opts.set_bottommost_zstd_max_train_bytes(1600 * 1024, true); - } - } - - opts.set_block_based_table_factory(&block_based_options); - - opts - } -} diff --git a/benchmark_results/run_20241213_195732/results.json b/benchmark_results/run_20241213_195732/results.json deleted file mode 100644 index 048a63848..000000000 --- a/benchmark_results/run_20241213_195732/results.json +++ /dev/null @@ -1,21 +0,0 @@ -{ - "run_id": "bench-3256568594", - "rps_summary": { - "max": 2522.0, - "min": 215.0, - "average": 1298.9497361843933, - "std_dev": 80.92682694695664 - }, - "tps_summary": { - "max": 1541.0, - "min": 57.0, - "average": 1298.4508333333333, - "std_dev": 80.01421626724287 - }, - "revert_summary": { - "max": 0.0, - "min": 0.0, - "average": 0.0, - "std_dev": 0.0 - } -} \ No newline at end of file diff --git a/benchmark_results/summary.md b/benchmark_results/summary.md deleted file mode 100644 index 4684080e3..000000000 --- a/benchmark_results/summary.md +++ /dev/null @@ -1,49 +0,0 @@ -| Config Tested | Max TPS | Avg TPS | Avg Read Time Per Slot | Avg Time to Save Block | -| -------------------------------------------------------------------------------- | ------- | ------- | ---------------------- | ---------------------- | -| main | 1135 | 1029 | 41.8us | 131ms | -| minimal | 1480 | 1092 | 41.6us | 126ms | -| OptimizeForPointLookup | 1567 | 1200 | 38.3us | 133ms | -| Prefix Extractor | 1558 | 1171 | 38.8us | 127ms | -| Row Cache | 1498 | 1136 | 38.1us | 125ms | -| HashSearch Index Type | 1575 | 1204 | 38.8us | 140ms | -| Direct IO | 1536 | 1148 | 38.5us | 123ms | -| HashSkipList memtable | 1544 | 1197 | 38.5us | 197ms | -| _Configs After this point are based on DirectIO config_ | | | | | -| PlainTable | 1498 | 1134 | 38.8us | 126ms | -| Small Hash Ratio | 1508 | 1201 | 38.4us | 132ms | -| Large Hash Ratio | 1505 | 1136 | 38.8us | 131ms | -| Large PrefixBloom Ratio | 1554 | 1152 | 39.8us | 133ms | -| Small Block Size | 1378 | 1039 | 40.0us | 117ms | -| Large Block Size | 1339 | 1019 | 41.0us | 124ms | -| Hyperclock Cache | 1709 | 1153 | 38.4us | 132ms | -| _Configs After this point are the final configs created using the results above_ | | | | | -| final_01 | 1521 | 1111 | 39.4us | 137ms | -| final_02 | 1517 | 1091 | 38.3us | 144ms | -| final_03 | 1552 | 1126 | 39.1us | 146ms | -| -------------------------------------------------------------------------------- | ------- | ------- | ---------------------- | ---------------------- | - -It was observed that rocksdb metrics (collected by rocks itself) were having a huge impact on point-lookups and adding a lot of variance, so the final tests were rerun -without collecting those metrics - -| Config Tested | Max TPS | Avg TPS | Avg Read Time Per Slot | Avg Time to Save Block | -| -------------------------------------------------------------------------------- | ------- | ------- | ---------------------- | ---------------------- | -| final_01 | 1464 | 1249 | 6.53us | 122ms | -| final_02 | 1461 | 1271 | 6.77us | 113ms | -| final_03 | 1541 | 1298 | 6.45us | 113ms | -| -------------------------------------------------------------------------------- | ------- | ------- | ---------------------- | ---------------------- | - -A lot of the differences between the tests can be attributed to variance, so final_03 was selected as the configuration candidate for having -a sensible configuration that should increase performance, stability and reliability, besides being much simpler than what we have today. -I truly believe that this config is very close to optimal in terms of striking a balance between point-lookup performance and stability+reliability. - -As an extra some other tests were done by changing the VM + disk type: - -| Config Tested | Max TPS | Avg TPS | Avg Read Time Per Slot | Avg Time to Save Block | -| -------------------------------------------------------------------------- | ------- | ------- | ---------------------- | ---------------------- | -| n2-standard-128 (intel ice lake) + extreme disk 120000 IOPS | 1694 | 1483 | 4.98us | 115ms | -| n4 + hyperdisk balanced | 1551 | 1443 | 5.30us | 109ms | -| n4 + hyperdisk balanced (metrics disaled) | 1656 | 1473 | | | -| n4 + hyperdisk balanced (logs level warn) | 1938 | 1716 | 4.79us | 130ms | -| n4 + hyperdisk balanced (metrics disabled and logs level warn) | 2143 | 1893 | | | -| n4 + hyperdisk balanced (metrics and tracing disabled and logs level warn) | 2200 | 1926 | | | -| -------------------------------------------------------------------------- | ------- | ------- | ---------------------- | ---------------------- | diff --git a/src/bin/rocks_migration.rs b/src/bin/rocks_migration.rs deleted file mode 100644 index 82f628f23..000000000 --- a/src/bin/rocks_migration.rs +++ /dev/null @@ -1,285 +0,0 @@ -use std::collections::HashMap; - -use anyhow::bail; -use anyhow::Context; -use anyhow::Result; -use rocksdb::IteratorMode; -use rocksdb::WaitForCompactOptions; -use rocksdb::WriteBatch; -use rocksdb::DB; -use stratus::eth::storage::permanent::rocks::rocks_db::create_or_open_db; - -const COLUMN_FAMILIES: [&str; 7] = [ - "accounts", - "account_slots", - "accounts_history", - "account_slots_history", - "transactions", - "blocks_by_number", - "blocks_by_hash", -]; - -pub fn main() -> Result<()> { - tracing_subscriber::fmt() - .with_env_filter(tracing_subscriber::EnvFilter::from_default_env()) - .init(); - - let args: Vec = std::env::args().collect(); - if args.len() != 3 { - bail!("Expected 2 arguments: source and destination DB paths"); - } - - tracing::info!("Opening source DB..."); - let (source_state, _) = create_or_open_db(args[1].clone(), &generate_old_cf_options_map(Some(0.1)))?; - - tracing::info!("Opening destination DB..."); - let (dest_state, _) = create_or_open_db(args[2].clone(), &generate_cf_options_map(Some(0.1)))?; - - for cf_handle in COLUMN_FAMILIES.into_iter() { - println!("Processing column family {}...", cf_handle); - tracing::info!("Processing column family {cf_handle}..."); - - let source_cf = source_state.cf_handle(&cf_handle).unwrap(); - let dest_cf = dest_state.cf_handle(&cf_handle).unwrap(); - - let mut batch = WriteBatch::default(); - let mut count = 0; - - for item in source_state.iterator_cf(&source_cf, IteratorMode::Start) { - let (key, value) = item?; - tracing::debug!("{} key length: {}", cf_handle, key.len()); - batch.put_cf(&dest_cf, key, value); - count += 1; - - if count % 10_000 == 0 { - tracing::info!("Processed {count} entries for CF {cf_handle}"); - write_in_batch(&dest_state, batch)?; - batch = WriteBatch::default(); - } - } - - if !batch.is_empty() { - write_in_batch(&dest_state, batch)?; - } - - tracing::info!("Completed column family {cf_handle} with {count} entries"); - } - - tracing::info!("Waiting for compactions"); - let mut wait_options = WaitForCompactOptions::default(); - wait_options.set_flush(true); - dest_state.wait_for_compact(&wait_options)?; - tracing::info!("Successfully copied all column families"); - - Ok(()) -} - -// ╔═══════════════════════════════════════════════════════════════════════════╗ -// ║ ║ -// ║ HELPERS ║ -// ║ ║ -// ╚═══════════════════════════════════════════════════════════════════════════╝ - -pub fn write_in_batch(db: &DB, batch: WriteBatch) -> anyhow::Result<()> { - tracing::debug!("writing batch"); - db.write(batch).context("failed to write batch") -} - -// ╔═══════════════════════════════════════════════════════════════════════════╗ -// ║ ║ -// ║ OLD CONFIG ║ -// ║ ║ -// ╚═══════════════════════════════════════════════════════════════════════════╝ - -use rocksdb::BlockBasedOptions; -use rocksdb::Cache; -use rocksdb::Options; -use stratus::eth::storage::permanent::rocks::rocks_state::generate_cf_options_map; -use sugars::hmap; - -const GIGABYTE: usize = 1024 * 1024 * 1024; -const MEGABYTE: usize = 1024 * 1024; -const KILOBYTE: usize = 1024; - -const GIGABYTE_U64: u64 = 1024 * 1024 * 1024; -const MEGABYTE_U64: u64 = 1024 * 1024; - -#[derive(Debug, Clone, Copy)] -pub enum CacheSetting { - /// Enabled cache with the given size in bytes - Enabled(usize), - Disabled, -} - -#[derive(Debug, Clone, Copy)] -pub enum OldDbConfig { - LargeSSTFiles, - FastWriteSST, - Default, -} - -impl Default for OldDbConfig { - fn default() -> Self { - Self::Default - } -} - -impl OldDbConfig { - pub fn to_options(self, cache_setting: CacheSetting) -> Options { - let mut opts = Options::default(); - let mut block_based_options = BlockBasedOptions::default(); - - opts.create_if_missing(true); - opts.create_missing_column_families(true); - opts.increase_parallelism(16); - - // NOTE: As per the rocks db wiki: "The overhead of statistics is usually small but non-negligible. We usually observe an overhead of 5%-10%." - #[cfg(feature = "metrics")] - { - opts.enable_statistics(); - opts.set_statistics_level(rocksdb::statistics::StatsLevel::ExceptTimeForMutex); - } - - match self { - OldDbConfig::LargeSSTFiles => { - // Set the compaction style to Level Compaction - opts.set_compaction_style(rocksdb::DBCompactionStyle::Level); - - // Configure the size of SST files at each level - opts.set_target_file_size_base(512 * MEGABYTE_U64); - - // Increase the file size multiplier to expand file size at upper levels - opts.set_target_file_size_multiplier(2); // Each level grows in file size quicker - - // Reduce the number of L0 files that trigger compaction, increasing frequency - opts.set_level_zero_file_num_compaction_trigger(2); - - // Reduce thresholds for slowing and stopping writes, which forces more frequent compaction - opts.set_level_zero_slowdown_writes_trigger(10); - opts.set_level_zero_stop_writes_trigger(20); - - // Increase the max bytes for L1 to allow more data before triggering compaction - opts.set_max_bytes_for_level_base(2 * GIGABYTE_U64); - - // Increase the level multiplier to aggressively increase space at each level - opts.set_max_bytes_for_level_multiplier(8.0); // Exponential growth of levels is more pronounced - - // Configure block size to optimize for larger blocks, improving sequential read performance - block_based_options.set_block_size(128 * KILOBYTE); - - // Increase the number of write buffers to delay flushing, optimizing CPU usage for compaction - opts.set_max_write_buffer_number(5); - opts.set_write_buffer_size(128 * MEGABYTE); // 128MB per write buffer - - // Keep a higher number of open files to accommodate more files being produced by aggressive compaction - opts.set_max_open_files(20_000); - - // Apply more aggressive compression settings, if I/O and CPU permit - opts.set_compression_per_level(&[ - rocksdb::DBCompressionType::Lz4, - rocksdb::DBCompressionType::Zstd, // Use Zstd for higher compression from L1 onwards - ]); - } - OldDbConfig::FastWriteSST => { - // Continue using Level Compaction due to its effective use of I/O and CPU for writes - opts.set_compaction_style(rocksdb::DBCompactionStyle::Level); - - // Increase initial SST file sizes to reduce the frequency of writes to disk - opts.set_target_file_size_base(512 * MEGABYTE_U64); // Starting at 512MB for L1 - - // Minimize the file size multiplier to control the growth of file sizes at upper levels - opts.set_target_file_size_multiplier(1); // Minimal increase in file size at upper levels - - // Increase triggers for write slowdown and stop to maximize buffer before I/O actions - opts.set_level_zero_file_num_compaction_trigger(100); // Slow down writes at 100 L0 files - opts.set_level_zero_stop_writes_trigger(200); // Stop writes at 200 L0 files - - // Expand the maximum bytes for base level to further delay the need for compaction-related I/O - opts.set_max_bytes_for_level_base(2048 * MEGABYTE_U64); - - // Use a higher level multiplier to increase space exponentially at higher levels - opts.set_max_bytes_for_level_multiplier(10.0); - - // Opt for larger block sizes to decrease the number of read and write operations to disk - block_based_options.set_block_size(512 * KILOBYTE); // 512KB blocks - - // Maximize the use of write buffers to extend the time data stays in memory before flushing - opts.set_max_write_buffer_number(16); - opts.set_write_buffer_size(GIGABYTE); // 1GB per write buffer - - // Allow a very high number of open files to minimize the overhead of opening and closing files - opts.set_max_open_files(20_000); - - // Choose compression that balances CPU use and effective storage reduction - opts.set_compression_per_level(&[rocksdb::DBCompressionType::Lz4, rocksdb::DBCompressionType::Zstd]); - - // Enable settings that make full use of CPU to handle more data in memory and process compaction - opts.set_allow_concurrent_memtable_write(true); - opts.set_enable_write_thread_adaptive_yield(true); - } - OldDbConfig::Default => { - block_based_options.set_ribbon_filter(15.5); // https://github.com/facebook/rocksdb/wiki/RocksDB-Bloom-Filter - - opts.set_allow_concurrent_memtable_write(true); - opts.set_enable_write_thread_adaptive_yield(true); - - let transform = rocksdb::SliceTransform::create_fixed_prefix(10); - opts.set_prefix_extractor(transform); - opts.set_memtable_prefix_bloom_ratio(0.2); - - // Enable a size-tiered compaction style, which is good for workloads with a high rate of updates and overwrites - opts.set_compaction_style(rocksdb::DBCompactionStyle::Universal); - - let mut universal_compact_options = rocksdb::UniversalCompactOptions::default(); - universal_compact_options.set_size_ratio(10); - universal_compact_options.set_min_merge_width(2); - universal_compact_options.set_max_merge_width(6); - universal_compact_options.set_max_size_amplification_percent(50); - universal_compact_options.set_compression_size_percent(-1); - universal_compact_options.set_stop_style(rocksdb::UniversalCompactionStopStyle::Total); - opts.set_universal_compaction_options(&universal_compact_options); - - let pt_opts = rocksdb::PlainTableFactoryOptions { - user_key_length: 0, - bloom_bits_per_key: 10, - hash_table_ratio: 0.75, - index_sparseness: 8, - encoding_type: rocksdb::KeyEncodingType::Plain, // Default encoding - full_scan_mode: false, // Optimized for point lookups rather than full scans - huge_page_tlb_size: 0, // Not using huge pages - store_index_in_file: false, // Store index in memory for faster access - }; - opts.set_plain_table_factory(&pt_opts); - } - } - if let CacheSetting::Enabled(cache_size) = cache_setting { - let cache = Cache::new_lru_cache(cache_size); - block_based_options.set_block_cache(&cache); - block_based_options.set_cache_index_and_filter_blocks(true); - } - opts.set_block_based_table_factory(&block_based_options); - opts - } -} - -fn generate_old_cf_options_map(cache_multiplier: Option) -> HashMap<&'static str, Options> { - let cache_multiplier = cache_multiplier.unwrap_or(1.0); - - // multiplies the given size in GBs by the cache multiplier - let cached_in_gigs_and_multiplied = |size_in_gbs: u64| -> CacheSetting { - let size = (size_in_gbs as f32) * cache_multiplier; - let size = GIGABYTE * size as usize; - CacheSetting::Enabled(size) - }; - - hmap! { - "accounts" => OldDbConfig::Default.to_options(cached_in_gigs_and_multiplied(15)), - "accounts_history" => OldDbConfig::FastWriteSST.to_options(CacheSetting::Disabled), - "account_slots" => OldDbConfig::Default.to_options(cached_in_gigs_and_multiplied(45)), - "account_slots_history" => OldDbConfig::FastWriteSST.to_options(CacheSetting::Disabled), - "transactions" => OldDbConfig::LargeSSTFiles.to_options(CacheSetting::Disabled), - "blocks_by_number" => OldDbConfig::LargeSSTFiles.to_options(CacheSetting::Disabled), - "blocks_by_hash" => OldDbConfig::LargeSSTFiles.to_options(CacheSetting::Disabled), - "logs" => OldDbConfig::LargeSSTFiles.to_options(CacheSetting::Disabled), - } -} diff --git a/utils/benchmark_rocks_config/configs/config_15_Final_01.rs b/utils/benchmark_rocks_config/configs/config_15_Final_01.rs deleted file mode 100644 index 7050f86a2..000000000 --- a/utils/benchmark_rocks_config/configs/config_15_Final_01.rs +++ /dev/null @@ -1,72 +0,0 @@ -use rocksdb::BlockBasedOptions; -use rocksdb::Cache; -use rocksdb::Options; - -pub enum CacheSetting { - /// Enabled cache with the given size in bytes - Enabled(usize), - Disabled, -} - -#[derive(Debug, Clone, Copy)] -pub enum DbConfig { - OptimizedPointLookUp, - Default, -} - -impl Default for DbConfig { - fn default() -> Self { - Self::Default - } -} - -impl DbConfig { - pub fn to_options(self, cache_setting: CacheSetting, prefix_len: Option, _key_len: usize) -> Options { - let mut opts = Options::default(); - let mut block_based_options = BlockBasedOptions::default(); - - opts.create_if_missing(true); - opts.create_missing_column_families(true); - opts.increase_parallelism(16); - - block_based_options.set_pin_l0_filter_and_index_blocks_in_cache(true); - block_based_options.set_cache_index_and_filter_blocks(true); - block_based_options.set_bloom_filter(15.5, false); - - if let Some(prefix_len) = prefix_len { - let transform = rocksdb::SliceTransform::create_fixed_prefix(prefix_len); - block_based_options.set_index_type(rocksdb::BlockBasedIndexType::HashSearch); - opts.set_memtable_prefix_bloom_ratio(0.15); - opts.set_prefix_extractor(transform); - } - - if let CacheSetting::Enabled(cache_size) = cache_setting { - let block_cache = Cache::new_hyper_clock_cache(cache_size/2, 0); - let row_cache = Cache::new_hyper_clock_cache(cache_size/2, 0); - - opts.set_row_cache(&row_cache); - block_based_options.set_block_cache(&block_cache); - } - - match self { - DbConfig::OptimizedPointLookUp => { - block_based_options.set_data_block_hash_ratio(0.3); - block_based_options.set_data_block_index_type(rocksdb::DataBlockIndexType::BinaryAndHash); - - opts.set_use_direct_reads(true); - opts.set_memtable_whole_key_filtering(true); - opts.set_compression_type(rocksdb::DBCompressionType::None); - } - DbConfig::Default => { - opts.set_compression_type(rocksdb::DBCompressionType::Lz4); - opts.set_bottommost_compression_type(rocksdb::DBCompressionType::Zstd); - opts.set_bottommost_compression_options(-14, 32767, 0, 16 * 1024, true); // mostly defaults except max_dict_bytes - opts.set_bottommost_zstd_max_train_bytes(1600 * 1024, true); - } - } - - opts.set_block_based_table_factory(&block_based_options); - - opts - } -} diff --git a/utils/benchmark_rocks_config/configs/config_16_Final_02.rs b/utils/benchmark_rocks_config/configs/config_16_Final_02.rs deleted file mode 100644 index e2b5995c7..000000000 --- a/utils/benchmark_rocks_config/configs/config_16_Final_02.rs +++ /dev/null @@ -1,72 +0,0 @@ -use rocksdb::BlockBasedOptions; -use rocksdb::Cache; -use rocksdb::Options; - -pub enum CacheSetting { - /// Enabled cache with the given size in bytes - Enabled(usize), - Disabled, -} - -#[derive(Debug, Clone, Copy)] -pub enum DbConfig { - OptimizedPointLookUp, - Default, -} - -impl Default for DbConfig { - fn default() -> Self { - Self::Default - } -} - -impl DbConfig { - pub fn to_options(self, cache_setting: CacheSetting, prefix_len: Option, _key_len: usize) -> Options { - let mut opts = Options::default(); - let mut block_based_options = BlockBasedOptions::default(); - - opts.create_if_missing(true); - opts.create_missing_column_families(true); - opts.increase_parallelism(16); - - block_based_options.set_pin_l0_filter_and_index_blocks_in_cache(true); - block_based_options.set_cache_index_and_filter_blocks(true); - block_based_options.set_bloom_filter(15.5, false); - - if let Some(prefix_len) = prefix_len { - let transform = rocksdb::SliceTransform::create_fixed_prefix(prefix_len); - block_based_options.set_index_type(rocksdb::BlockBasedIndexType::HashSearch); - opts.set_memtable_prefix_bloom_ratio(0.15); - opts.set_prefix_extractor(transform); - } - - if let CacheSetting::Enabled(cache_size) = cache_setting { - let block_cache = Cache::new_lru_cache(cache_size/2); - let row_cache = Cache::new_lru_cache(cache_size/2); - - opts.set_row_cache(&row_cache); - block_based_options.set_block_cache(&block_cache); - } - - match self { - DbConfig::OptimizedPointLookUp => { - block_based_options.set_data_block_hash_ratio(0.3); - block_based_options.set_data_block_index_type(rocksdb::DataBlockIndexType::BinaryAndHash); - - opts.set_use_direct_reads(true); - opts.set_memtable_whole_key_filtering(true); - opts.set_compression_type(rocksdb::DBCompressionType::None); - } - DbConfig::Default => { - opts.set_compression_type(rocksdb::DBCompressionType::Lz4); - opts.set_bottommost_compression_type(rocksdb::DBCompressionType::Zstd); - opts.set_bottommost_compression_options(-14, 32767, 0, 16 * 1024, true); // mostly defaults except max_dict_bytes - opts.set_bottommost_zstd_max_train_bytes(1600 * 1024, true); - } - } - - opts.set_block_based_table_factory(&block_based_options); - - opts - } -} diff --git a/utils/benchmark_rocks_config/configs/config_17_Final_03.rs b/utils/benchmark_rocks_config/configs/config_17_Final_03.rs deleted file mode 100644 index e2b5995c7..000000000 --- a/utils/benchmark_rocks_config/configs/config_17_Final_03.rs +++ /dev/null @@ -1,72 +0,0 @@ -use rocksdb::BlockBasedOptions; -use rocksdb::Cache; -use rocksdb::Options; - -pub enum CacheSetting { - /// Enabled cache with the given size in bytes - Enabled(usize), - Disabled, -} - -#[derive(Debug, Clone, Copy)] -pub enum DbConfig { - OptimizedPointLookUp, - Default, -} - -impl Default for DbConfig { - fn default() -> Self { - Self::Default - } -} - -impl DbConfig { - pub fn to_options(self, cache_setting: CacheSetting, prefix_len: Option, _key_len: usize) -> Options { - let mut opts = Options::default(); - let mut block_based_options = BlockBasedOptions::default(); - - opts.create_if_missing(true); - opts.create_missing_column_families(true); - opts.increase_parallelism(16); - - block_based_options.set_pin_l0_filter_and_index_blocks_in_cache(true); - block_based_options.set_cache_index_and_filter_blocks(true); - block_based_options.set_bloom_filter(15.5, false); - - if let Some(prefix_len) = prefix_len { - let transform = rocksdb::SliceTransform::create_fixed_prefix(prefix_len); - block_based_options.set_index_type(rocksdb::BlockBasedIndexType::HashSearch); - opts.set_memtable_prefix_bloom_ratio(0.15); - opts.set_prefix_extractor(transform); - } - - if let CacheSetting::Enabled(cache_size) = cache_setting { - let block_cache = Cache::new_lru_cache(cache_size/2); - let row_cache = Cache::new_lru_cache(cache_size/2); - - opts.set_row_cache(&row_cache); - block_based_options.set_block_cache(&block_cache); - } - - match self { - DbConfig::OptimizedPointLookUp => { - block_based_options.set_data_block_hash_ratio(0.3); - block_based_options.set_data_block_index_type(rocksdb::DataBlockIndexType::BinaryAndHash); - - opts.set_use_direct_reads(true); - opts.set_memtable_whole_key_filtering(true); - opts.set_compression_type(rocksdb::DBCompressionType::None); - } - DbConfig::Default => { - opts.set_compression_type(rocksdb::DBCompressionType::Lz4); - opts.set_bottommost_compression_type(rocksdb::DBCompressionType::Zstd); - opts.set_bottommost_compression_options(-14, 32767, 0, 16 * 1024, true); // mostly defaults except max_dict_bytes - opts.set_bottommost_zstd_max_train_bytes(1600 * 1024, true); - } - } - - opts.set_block_based_table_factory(&block_based_options); - - opts - } -} diff --git a/utils/benchmark_rocks_config/main.py b/utils/benchmark_rocks_config/main.py deleted file mode 100644 index fd8f29415..000000000 --- a/utils/benchmark_rocks_config/main.py +++ /dev/null @@ -1,158 +0,0 @@ -import os -import signal -import shutil -import json -import time -import subprocess -import requests -from pathlib import Path - -# Configuration -SRC_CONFIG_PATH = "../../src/eth/storage/permanent/rocks/rocks_config.rs" -CONFIGS_FOLDER = "./configs" # folder containing different config files -BENCHMARK_SERVICE_IP = "http://10.52.184.7:3232" -RESULTS_DIR = "benchmark_results" - -def replace_config(config_file): - """Replace the config file in src with the provided one""" - shutil.copy(config_file, SRC_CONFIG_PATH) - print(f"Replaced config with {config_file}") - -def run_migration(): - """Run the database migration""" - process = subprocess.run( - ["cargo", "run", "--release", "--bin", "rocks_migration", "--", "../../old_data/rocksdb", "../../data/rocksdb"], - env=dict(os.environ, RUST_LOG="info"), - check=True, - stdout=open("migration.log", "w") - ) - print("Migration completed") - -def run_stratus(): - """Run the stratus program and return the process""" - process = subprocess.Popen( - ["cargo", "run", "--release", "--bin", "stratus", "--", "--leader"], - preexec_fn=os.setsid, # Creates a new process group, - cwd="../../", - stdout=open("stratus.log", "w"), - ) - print("Started stratus") - # Give it some time to start up - print("Waiting for stratus to start...") - port_open = False - while not port_open: - try: - result = subprocess.run(["lsof", "-i", ":3000"], capture_output=True, text=True) - if result.stdout: - port_open = True - else: - time.sleep(1) - except subprocess.CalledProcessError: - time.sleep(1) - print("Port 3000 is now in use, stratus has started") - return process - -def start_benchmark(): - """Start the benchmark on the external service""" - benchmark_data = { - "target_account_strategy": "Random", - "cashier_contract_address": "0x6ac607aBA84f672C092838a5c32c22907765F666", - "private_keys_file": "keys_new.txt", - "http_address": "http://10.52.184.4:3000", - "amp_step": 100, - "ramp_interval": 1, - "run_duration": 3600 - } - - response = requests.post( - f"{BENCHMARK_SERVICE_IP}/start", - json=benchmark_data, - headers={"Content-Type": "application/json"} - ) - response.raise_for_status() - print("Benchmark started") - -def wait_for_benchmark(): - """Poll the benchmark service until completion and return results""" - while True: - response = requests.get(f"{BENCHMARK_SERVICE_IP}/status") - response.raise_for_status() - status = response.json() - - if not status["is_running"]: - print("Benchmark completed") - return status["latest_results"] - - time.sleep(10) # Poll every 10 seconds - -def save_results(config_file: Path, results): - """Save the results and config to a new directory""" - # Create unique directory name based on timestamp - timestamp = time.strftime("%Y%m%d_%H%M%S") - result_dir = Path(RESULTS_DIR) / f"run_{timestamp}" - result_dir.mkdir(parents=True, exist_ok=True) - - # Copy config file - shutil.copy(config_file, result_dir / config_file.name) # Use config_file.name instead of full path - - # Save results - result_file = result_dir / "results.json" - with open(str(result_file), "w") as f: # Convert Path to string - json.dump(results, f, indent=2) - - print(f"Results saved in {result_dir}") - -def main(): - # Create results directory if it doesn't exist - Path(RESULTS_DIR).mkdir(exist_ok=True) - - # Get all config files - config_files = list(Path(CONFIGS_FOLDER).glob("*.rs")) - - for config_file in sorted(config_files): - # Delete files in the previous database - db_path = Path("../../data") - if db_path.exists(): - for item in db_path.iterdir(): - if item.is_file(): - item.unlink() - elif item.is_dir(): - shutil.rmtree(item) - print("Cleared previous database contents") - db_path.mkdir(parents=True, exist_ok=True) - - print(f"\nTesting config: {config_file}") - try: - # 1. Replace config - replace_config(config_file) - - # 2. Run migration - run_migration() - - # 3. Start the program - stratus_process = run_stratus() - - try: - # 4. Start benchmark - start_benchmark() - - # 5. Wait for benchmark completion - results = wait_for_benchmark() - - # 6. Save results and stop program - save_results(config_file, results) - - finally: - # Ensure we always try to stop the program - if stratus_process: - # Send SIGTERM to the process group - os.killpg(os.getpgid(stratus_process.pid), signal.SIGTERM) - stratus_process.wait() - print("Stratus stopped") - - except Exception as e: - print(f"Error processing {config_file}: {e}") - continue - -if __name__ == "__main__": - main() diff --git a/utils/benchmark_rocks_config/poetry.lock b/utils/benchmark_rocks_config/poetry.lock deleted file mode 100644 index 2630d1a48..000000000 --- a/utils/benchmark_rocks_config/poetry.lock +++ /dev/null @@ -1,183 +0,0 @@ -# This file is automatically @generated by Poetry 1.8.4 and should not be changed by hand. - -[[package]] -name = "certifi" -version = "2024.8.30" -description = "Python package for providing Mozilla's CA Bundle." -optional = false -python-versions = ">=3.6" -files = [ - {file = "certifi-2024.8.30-py3-none-any.whl", hash = "sha256:922820b53db7a7257ffbda3f597266d435245903d80737e34f8a45ff3e3230d8"}, - {file = "certifi-2024.8.30.tar.gz", hash = "sha256:bec941d2aa8195e248a60b31ff9f0558284cf01a52591ceda73ea9afffd69fd9"}, -] - -[[package]] -name = "charset-normalizer" -version = "3.4.0" -description = "The Real First Universal Charset Detector. Open, modern and actively maintained alternative to Chardet." -optional = false -python-versions = ">=3.7.0" -files = [ - {file = "charset_normalizer-3.4.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:4f9fc98dad6c2eaa32fc3af1417d95b5e3d08aff968df0cd320066def971f9a6"}, - {file = "charset_normalizer-3.4.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:0de7b687289d3c1b3e8660d0741874abe7888100efe14bd0f9fd7141bcbda92b"}, - {file = "charset_normalizer-3.4.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:5ed2e36c3e9b4f21dd9422f6893dec0abf2cca553af509b10cd630f878d3eb99"}, - {file = "charset_normalizer-3.4.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:40d3ff7fc90b98c637bda91c89d51264a3dcf210cade3a2c6f838c7268d7a4ca"}, - {file = "charset_normalizer-3.4.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1110e22af8ca26b90bd6364fe4c763329b0ebf1ee213ba32b68c73de5752323d"}, - {file = "charset_normalizer-3.4.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:86f4e8cca779080f66ff4f191a685ced73d2f72d50216f7112185dc02b90b9b7"}, - {file = "charset_normalizer-3.4.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7f683ddc7eedd742e2889d2bfb96d69573fde1d92fcb811979cdb7165bb9c7d3"}, - {file = "charset_normalizer-3.4.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:27623ba66c183eca01bf9ff833875b459cad267aeeb044477fedac35e19ba907"}, - {file = "charset_normalizer-3.4.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:f606a1881d2663630ea5b8ce2efe2111740df4b687bd78b34a8131baa007f79b"}, - {file = "charset_normalizer-3.4.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:0b309d1747110feb25d7ed6b01afdec269c647d382c857ef4663bbe6ad95a912"}, - {file = "charset_normalizer-3.4.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:136815f06a3ae311fae551c3df1f998a1ebd01ddd424aa5603a4336997629e95"}, - {file = "charset_normalizer-3.4.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:14215b71a762336254351b00ec720a8e85cada43b987da5a042e4ce3e82bd68e"}, - {file = "charset_normalizer-3.4.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:79983512b108e4a164b9c8d34de3992f76d48cadc9554c9e60b43f308988aabe"}, - {file = "charset_normalizer-3.4.0-cp310-cp310-win32.whl", hash = "sha256:c94057af19bc953643a33581844649a7fdab902624d2eb739738a30e2b3e60fc"}, - {file = "charset_normalizer-3.4.0-cp310-cp310-win_amd64.whl", hash = "sha256:55f56e2ebd4e3bc50442fbc0888c9d8c94e4e06a933804e2af3e89e2f9c1c749"}, - {file = "charset_normalizer-3.4.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:0d99dd8ff461990f12d6e42c7347fd9ab2532fb70e9621ba520f9e8637161d7c"}, - {file = "charset_normalizer-3.4.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:c57516e58fd17d03ebe67e181a4e4e2ccab1168f8c2976c6a334d4f819fe5944"}, - {file = "charset_normalizer-3.4.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:6dba5d19c4dfab08e58d5b36304b3f92f3bd5d42c1a3fa37b5ba5cdf6dfcbcee"}, - {file = "charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bf4475b82be41b07cc5e5ff94810e6a01f276e37c2d55571e3fe175e467a1a1c"}, - {file = "charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ce031db0408e487fd2775d745ce30a7cd2923667cf3b69d48d219f1d8f5ddeb6"}, - {file = "charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8ff4e7cdfdb1ab5698e675ca622e72d58a6fa2a8aa58195de0c0061288e6e3ea"}, - {file = "charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3710a9751938947e6327ea9f3ea6332a09bf0ba0c09cae9cb1f250bd1f1549bc"}, - {file = "charset_normalizer-3.4.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:82357d85de703176b5587dbe6ade8ff67f9f69a41c0733cf2425378b49954de5"}, - {file = "charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:47334db71978b23ebcf3c0f9f5ee98b8d65992b65c9c4f2d34c2eaf5bcaf0594"}, - {file = "charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:8ce7fd6767a1cc5a92a639b391891bf1c268b03ec7e021c7d6d902285259685c"}, - {file = "charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:f1a2f519ae173b5b6a2c9d5fa3116ce16e48b3462c8b96dfdded11055e3d6365"}, - {file = "charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:63bc5c4ae26e4bc6be6469943b8253c0fd4e4186c43ad46e713ea61a0ba49129"}, - {file = "charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:bcb4f8ea87d03bc51ad04add8ceaf9b0f085ac045ab4d74e73bbc2dc033f0236"}, - {file = "charset_normalizer-3.4.0-cp311-cp311-win32.whl", hash = "sha256:9ae4ef0b3f6b41bad6366fb0ea4fc1d7ed051528e113a60fa2a65a9abb5b1d99"}, - {file = "charset_normalizer-3.4.0-cp311-cp311-win_amd64.whl", hash = "sha256:cee4373f4d3ad28f1ab6290684d8e2ebdb9e7a1b74fdc39e4c211995f77bec27"}, - {file = "charset_normalizer-3.4.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:0713f3adb9d03d49d365b70b84775d0a0d18e4ab08d12bc46baa6132ba78aaf6"}, - {file = "charset_normalizer-3.4.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:de7376c29d95d6719048c194a9cf1a1b0393fbe8488a22008610b0361d834ecf"}, - {file = "charset_normalizer-3.4.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:4a51b48f42d9358460b78725283f04bddaf44a9358197b889657deba38f329db"}, - {file = "charset_normalizer-3.4.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b295729485b06c1a0683af02a9e42d2caa9db04a373dc38a6a58cdd1e8abddf1"}, - {file = "charset_normalizer-3.4.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ee803480535c44e7f5ad00788526da7d85525cfefaf8acf8ab9a310000be4b03"}, - {file = "charset_normalizer-3.4.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3d59d125ffbd6d552765510e3f31ed75ebac2c7470c7274195b9161a32350284"}, - {file = "charset_normalizer-3.4.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8cda06946eac330cbe6598f77bb54e690b4ca93f593dee1568ad22b04f347c15"}, - {file = "charset_normalizer-3.4.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:07afec21bbbbf8a5cc3651aa96b980afe2526e7f048fdfb7f1014d84acc8b6d8"}, - {file = "charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6b40e8d38afe634559e398cc32b1472f376a4099c75fe6299ae607e404c033b2"}, - {file = "charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:b8dcd239c743aa2f9c22ce674a145e0a25cb1566c495928440a181ca1ccf6719"}, - {file = "charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:84450ba661fb96e9fd67629b93d2941c871ca86fc38d835d19d4225ff946a631"}, - {file = "charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:44aeb140295a2f0659e113b31cfe92c9061622cadbc9e2a2f7b8ef6b1e29ef4b"}, - {file = "charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:1db4e7fefefd0f548d73e2e2e041f9df5c59e178b4c72fbac4cc6f535cfb1565"}, - {file = "charset_normalizer-3.4.0-cp312-cp312-win32.whl", hash = "sha256:5726cf76c982532c1863fb64d8c6dd0e4c90b6ece9feb06c9f202417a31f7dd7"}, - {file = "charset_normalizer-3.4.0-cp312-cp312-win_amd64.whl", hash = "sha256:b197e7094f232959f8f20541ead1d9862ac5ebea1d58e9849c1bf979255dfac9"}, - {file = "charset_normalizer-3.4.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:dd4eda173a9fcccb5f2e2bd2a9f423d180194b1bf17cf59e3269899235b2a114"}, - {file = "charset_normalizer-3.4.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e9e3c4c9e1ed40ea53acf11e2a386383c3304212c965773704e4603d589343ed"}, - {file = "charset_normalizer-3.4.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:92a7e36b000bf022ef3dbb9c46bfe2d52c047d5e3f3343f43204263c5addc250"}, - {file = "charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:54b6a92d009cbe2fb11054ba694bc9e284dad30a26757b1e372a1fdddaf21920"}, - {file = "charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1ffd9493de4c922f2a38c2bf62b831dcec90ac673ed1ca182fe11b4d8e9f2a64"}, - {file = "charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:35c404d74c2926d0287fbd63ed5d27eb911eb9e4a3bb2c6d294f3cfd4a9e0c23"}, - {file = "charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4796efc4faf6b53a18e3d46343535caed491776a22af773f366534056c4e1fbc"}, - {file = "charset_normalizer-3.4.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e7fdd52961feb4c96507aa649550ec2a0d527c086d284749b2f582f2d40a2e0d"}, - {file = "charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:92db3c28b5b2a273346bebb24857fda45601aef6ae1c011c0a997106581e8a88"}, - {file = "charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:ab973df98fc99ab39080bfb0eb3a925181454d7c3ac8a1e695fddfae696d9e90"}, - {file = "charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:4b67fdab07fdd3c10bb21edab3cbfe8cf5696f453afce75d815d9d7223fbe88b"}, - {file = "charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:aa41e526a5d4a9dfcfbab0716c7e8a1b215abd3f3df5a45cf18a12721d31cb5d"}, - {file = "charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ffc519621dce0c767e96b9c53f09c5d215578e10b02c285809f76509a3931482"}, - {file = "charset_normalizer-3.4.0-cp313-cp313-win32.whl", hash = "sha256:f19c1585933c82098c2a520f8ec1227f20e339e33aca8fa6f956f6691b784e67"}, - {file = "charset_normalizer-3.4.0-cp313-cp313-win_amd64.whl", hash = "sha256:707b82d19e65c9bd28b81dde95249b07bf9f5b90ebe1ef17d9b57473f8a64b7b"}, - {file = "charset_normalizer-3.4.0-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:dbe03226baf438ac4fda9e2d0715022fd579cb641c4cf639fa40d53b2fe6f3e2"}, - {file = "charset_normalizer-3.4.0-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dd9a8bd8900e65504a305bf8ae6fa9fbc66de94178c420791d0293702fce2df7"}, - {file = "charset_normalizer-3.4.0-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b8831399554b92b72af5932cdbbd4ddc55c55f631bb13ff8fe4e6536a06c5c51"}, - {file = "charset_normalizer-3.4.0-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a14969b8691f7998e74663b77b4c36c0337cb1df552da83d5c9004a93afdb574"}, - {file = "charset_normalizer-3.4.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dcaf7c1524c0542ee2fc82cc8ec337f7a9f7edee2532421ab200d2b920fc97cf"}, - {file = "charset_normalizer-3.4.0-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:425c5f215d0eecee9a56cdb703203dda90423247421bf0d67125add85d0c4455"}, - {file = "charset_normalizer-3.4.0-cp37-cp37m-musllinux_1_2_aarch64.whl", hash = "sha256:d5b054862739d276e09928de37c79ddeec42a6e1bfc55863be96a36ba22926f6"}, - {file = "charset_normalizer-3.4.0-cp37-cp37m-musllinux_1_2_i686.whl", hash = "sha256:f3e73a4255342d4eb26ef6df01e3962e73aa29baa3124a8e824c5d3364a65748"}, - {file = "charset_normalizer-3.4.0-cp37-cp37m-musllinux_1_2_ppc64le.whl", hash = "sha256:2f6c34da58ea9c1a9515621f4d9ac379871a8f21168ba1b5e09d74250de5ad62"}, - {file = "charset_normalizer-3.4.0-cp37-cp37m-musllinux_1_2_s390x.whl", hash = "sha256:f09cb5a7bbe1ecae6e87901a2eb23e0256bb524a79ccc53eb0b7629fbe7677c4"}, - {file = "charset_normalizer-3.4.0-cp37-cp37m-musllinux_1_2_x86_64.whl", hash = "sha256:0099d79bdfcf5c1f0c2c72f91516702ebf8b0b8ddd8905f97a8aecf49712c621"}, - {file = "charset_normalizer-3.4.0-cp37-cp37m-win32.whl", hash = "sha256:9c98230f5042f4945f957d006edccc2af1e03ed5e37ce7c373f00a5a4daa6149"}, - {file = "charset_normalizer-3.4.0-cp37-cp37m-win_amd64.whl", hash = "sha256:62f60aebecfc7f4b82e3f639a7d1433a20ec32824db2199a11ad4f5e146ef5ee"}, - {file = "charset_normalizer-3.4.0-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:af73657b7a68211996527dbfeffbb0864e043d270580c5aef06dc4b659a4b578"}, - {file = "charset_normalizer-3.4.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:cab5d0b79d987c67f3b9e9c53f54a61360422a5a0bc075f43cab5621d530c3b6"}, - {file = "charset_normalizer-3.4.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:9289fd5dddcf57bab41d044f1756550f9e7cf0c8e373b8cdf0ce8773dc4bd417"}, - {file = "charset_normalizer-3.4.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6b493a043635eb376e50eedf7818f2f322eabbaa974e948bd8bdd29eb7ef2a51"}, - {file = "charset_normalizer-3.4.0-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9fa2566ca27d67c86569e8c85297aaf413ffab85a8960500f12ea34ff98e4c41"}, - {file = "charset_normalizer-3.4.0-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a8e538f46104c815be19c975572d74afb53f29650ea2025bbfaef359d2de2f7f"}, - {file = "charset_normalizer-3.4.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6fd30dc99682dc2c603c2b315bded2799019cea829f8bf57dc6b61efde6611c8"}, - {file = "charset_normalizer-3.4.0-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2006769bd1640bdf4d5641c69a3d63b71b81445473cac5ded39740a226fa88ab"}, - {file = "charset_normalizer-3.4.0-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:dc15e99b2d8a656f8e666854404f1ba54765871104e50c8e9813af8a7db07f12"}, - {file = "charset_normalizer-3.4.0-cp38-cp38-musllinux_1_2_i686.whl", hash = "sha256:ab2e5bef076f5a235c3774b4f4028a680432cded7cad37bba0fd90d64b187d19"}, - {file = "charset_normalizer-3.4.0-cp38-cp38-musllinux_1_2_ppc64le.whl", hash = "sha256:4ec9dd88a5b71abfc74e9df5ebe7921c35cbb3b641181a531ca65cdb5e8e4dea"}, - {file = "charset_normalizer-3.4.0-cp38-cp38-musllinux_1_2_s390x.whl", hash = "sha256:43193c5cda5d612f247172016c4bb71251c784d7a4d9314677186a838ad34858"}, - {file = "charset_normalizer-3.4.0-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:aa693779a8b50cd97570e5a0f343538a8dbd3e496fa5dcb87e29406ad0299654"}, - {file = "charset_normalizer-3.4.0-cp38-cp38-win32.whl", hash = "sha256:7706f5850360ac01d80c89bcef1640683cc12ed87f42579dab6c5d3ed6888613"}, - {file = "charset_normalizer-3.4.0-cp38-cp38-win_amd64.whl", hash = "sha256:c3e446d253bd88f6377260d07c895816ebf33ffffd56c1c792b13bff9c3e1ade"}, - {file = "charset_normalizer-3.4.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:980b4f289d1d90ca5efcf07958d3eb38ed9c0b7676bf2831a54d4f66f9c27dfa"}, - {file = "charset_normalizer-3.4.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:f28f891ccd15c514a0981f3b9db9aa23d62fe1a99997512b0491d2ed323d229a"}, - {file = "charset_normalizer-3.4.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:a8aacce6e2e1edcb6ac625fb0f8c3a9570ccc7bfba1f63419b3769ccf6a00ed0"}, - {file = "charset_normalizer-3.4.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bd7af3717683bea4c87acd8c0d3d5b44d56120b26fd3f8a692bdd2d5260c620a"}, - {file = "charset_normalizer-3.4.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5ff2ed8194587faf56555927b3aa10e6fb69d931e33953943bc4f837dfee2242"}, - {file = "charset_normalizer-3.4.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e91f541a85298cf35433bf66f3fab2a4a2cff05c127eeca4af174f6d497f0d4b"}, - {file = "charset_normalizer-3.4.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:309a7de0a0ff3040acaebb35ec45d18db4b28232f21998851cfa709eeff49d62"}, - {file = "charset_normalizer-3.4.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:285e96d9d53422efc0d7a17c60e59f37fbf3dfa942073f666db4ac71e8d726d0"}, - {file = "charset_normalizer-3.4.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:5d447056e2ca60382d460a604b6302d8db69476fd2015c81e7c35417cfabe4cd"}, - {file = "charset_normalizer-3.4.0-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:20587d20f557fe189b7947d8e7ec5afa110ccf72a3128d61a2a387c3313f46be"}, - {file = "charset_normalizer-3.4.0-cp39-cp39-musllinux_1_2_ppc64le.whl", hash = "sha256:130272c698667a982a5d0e626851ceff662565379baf0ff2cc58067b81d4f11d"}, - {file = "charset_normalizer-3.4.0-cp39-cp39-musllinux_1_2_s390x.whl", hash = "sha256:ab22fbd9765e6954bc0bcff24c25ff71dcbfdb185fcdaca49e81bac68fe724d3"}, - {file = "charset_normalizer-3.4.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:7782afc9b6b42200f7362858f9e73b1f8316afb276d316336c0ec3bd73312742"}, - {file = "charset_normalizer-3.4.0-cp39-cp39-win32.whl", hash = "sha256:2de62e8801ddfff069cd5c504ce3bc9672b23266597d4e4f50eda28846c322f2"}, - {file = "charset_normalizer-3.4.0-cp39-cp39-win_amd64.whl", hash = "sha256:95c3c157765b031331dd4db3c775e58deaee050a3042fcad72cbc4189d7c8dca"}, - {file = "charset_normalizer-3.4.0-py3-none-any.whl", hash = "sha256:fe9f97feb71aa9896b81973a7bbada8c49501dc73e58a10fcef6663af95e5079"}, - {file = "charset_normalizer-3.4.0.tar.gz", hash = "sha256:223217c3d4f82c3ac5e29032b3f1c2eb0fb591b72161f86d93f5719079dae93e"}, -] - -[[package]] -name = "idna" -version = "3.10" -description = "Internationalized Domain Names in Applications (IDNA)" -optional = false -python-versions = ">=3.6" -files = [ - {file = "idna-3.10-py3-none-any.whl", hash = "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3"}, - {file = "idna-3.10.tar.gz", hash = "sha256:12f65c9b470abda6dc35cf8e63cc574b1c52b11df2c86030af0ac09b01b13ea9"}, -] - -[package.extras] -all = ["flake8 (>=7.1.1)", "mypy (>=1.11.2)", "pytest (>=8.3.2)", "ruff (>=0.6.2)"] - -[[package]] -name = "requests" -version = "2.32.3" -description = "Python HTTP for Humans." -optional = false -python-versions = ">=3.8" -files = [ - {file = "requests-2.32.3-py3-none-any.whl", hash = "sha256:70761cfe03c773ceb22aa2f671b4757976145175cdfca038c02654d061d6dcc6"}, - {file = "requests-2.32.3.tar.gz", hash = "sha256:55365417734eb18255590a9ff9eb97e9e1da868d4ccd6402399eaf68af20a760"}, -] - -[package.dependencies] -certifi = ">=2017.4.17" -charset-normalizer = ">=2,<4" -idna = ">=2.5,<4" -urllib3 = ">=1.21.1,<3" - -[package.extras] -socks = ["PySocks (>=1.5.6,!=1.5.7)"] -use-chardet-on-py3 = ["chardet (>=3.0.2,<6)"] - -[[package]] -name = "urllib3" -version = "2.2.3" -description = "HTTP library with thread-safe connection pooling, file post, and more." -optional = false -python-versions = ">=3.8" -files = [ - {file = "urllib3-2.2.3-py3-none-any.whl", hash = "sha256:ca899ca043dcb1bafa3e262d73aa25c465bfb49e0bd9dd5d59f1d0acba2f8fac"}, - {file = "urllib3-2.2.3.tar.gz", hash = "sha256:e7d814a81dad81e6caf2ec9fdedb284ecc9c73076b62654547cc64ccdcae26e9"}, -] - -[package.extras] -brotli = ["brotli (>=1.0.9)", "brotlicffi (>=0.8.0)"] -h2 = ["h2 (>=4,<5)"] -socks = ["pysocks (>=1.5.6,!=1.5.7,<2.0)"] -zstd = ["zstandard (>=0.18.0)"] - -[metadata] -lock-version = "2.0" -python-versions = "^3.12" -content-hash = "b7d43347bb785deaa589eb2cc358aa369a37e8b7af7d45e021af9d53823d3bb5" diff --git a/utils/benchmark_rocks_config/pyproject.toml b/utils/benchmark_rocks_config/pyproject.toml deleted file mode 100644 index 02cb2ad1e..000000000 --- a/utils/benchmark_rocks_config/pyproject.toml +++ /dev/null @@ -1,16 +0,0 @@ -[tool.poetry] -name = "benchmark-rocks-config" -version = "0.1.0" -description = "" -authors = ["Daniel Freire "] -readme = "README.md" -package-mode = false - -[tool.poetry.dependencies] -python = "^3.10" -requests = "^2.32.3" - - -[build-system] -requires = ["poetry-core"] -build-backend = "poetry.core.masonry.api" diff --git a/utils/benchmark_rocks_config/pyrightconfig.json b/utils/benchmark_rocks_config/pyrightconfig.json deleted file mode 100644 index 85fe0ae9b..000000000 --- a/utils/benchmark_rocks_config/pyrightconfig.json +++ /dev/null @@ -1,4 +0,0 @@ -{ - "venvPath": ".", - "venv": "" -}