From 07f7bd9f01b0860ab45f5b924f3a4e9d38decc4c Mon Sep 17 00:00:00 2001 From: Aramik Date: Mon, 26 Aug 2024 14:01:38 -0700 Subject: [PATCH] Update database benchmarks (#2139) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit # Goal The goal of this PR is to calculate the DB benchmarks based on current main-net state. Related to #1853 # Warning - **Current PR will change all weights for stable weights** If that is not desirable, we can use defaults for stable weights but it would not be a correct metric for measuring consumed resources. # Discussion - Calculated the benchmark with `1.3` multiplier. If we expect to add more than 30% keys in the next 6 months we need to increase this multiplier. # Checklist - [X] Spec version incremented? # Execution steps 1. download a copy of mainnet chain data 2. build the same version of frequency that is running on mainnet by running `cargo build --release --features frequency,runtime-benchmarks` 3. run the storage benchmark by pointing the path to the copy of mainnet data like following `./target/release/frequency benchmark storage --state-version=1 --chain=frequency --base-path=/home/ubuntu/mainnet_data/ --include-child-trees --warmups=2 --mul=1.3` ```bash 2024-08-22 20:04:37 Warmup round 1/2 2024-08-22 20:09:03 Warmup round 2/2 2024-08-22 20:13:29 Preparing keys from block 0x09b2…00e2 2024-08-22 20:13:50 Reading 7585867 keys 2024-08-22 20:18:48 Reading 1705264 child keys 2024-08-22 20:19:57 Time summary [ns]: Total: 281753393895 Min: 1676, Max: 3967371 Average: 36369, Median: 36876, Stddev: 10368.83 Percentiles 99th, 95th, 75th: 60542, 52621, 43407 Value size summary: Total: 441863634 Min: 0, Max: 891362 Average: 57, Median: 8, Stddev: 363.51 Percentiles 99th, 95th, 75th: 1026, 253, 35 2024-08-22 20:20:18 Warmup round 1/2 2024-08-22 20:24:42 Warmup round 2/2 2024-08-22 20:29:06 Preparing keys from block 0x09b2…00e2 2024-08-22 20:29:29 Writing 7585867 keys 2024-08-22 20:53:04 Writing 1705264 child keys 2024-08-22 20:55:54 Time summary [ns]: Total: 443223318406 Min: 4954, Max: 87545132 Average: 57212, Median: 62141, Stddev: 60272.19 Percentiles 99th, 95th, 75th: 101820, 90948, 75800 Value size summary: Total: 441863634 Min: 0, Max: 891362 Average: 57, Median: 8, Stddev: 363.51 Percentiles 99th, 95th, 75th: 1026, 253, 35 2024-08-22 20:55:54 Writing weights to "/home/ubuntu/frequency/rocksdb_weights.rs" ``` --- pallets/capacity/src/lib.rs | 4 +- .../src/capacity_stable_weights.rs | 10 +- .../frequency-tx-payment/src/tests/mock.rs | 7 +- .../src/tests/stable_weights_tests.rs | 26 ++--- runtime/common/src/weights/mod.rs | 1 + runtime/common/src/weights/rocksdb_weights.rs | 95 +++++++++++++++++++ runtime/frequency/src/lib.rs | 7 +- 7 files changed, 125 insertions(+), 25 deletions(-) create mode 100644 runtime/common/src/weights/rocksdb_weights.rs diff --git a/pallets/capacity/src/lib.rs b/pallets/capacity/src/lib.rs index 6c071733e6..72defb7dfc 100644 --- a/pallets/capacity/src/lib.rs +++ b/pallets/capacity/src/lib.rs @@ -32,7 +32,7 @@ use frame_support::{ tokens::fungible::{Inspect as InspectFungible, InspectFreeze, Mutate, MutateFreeze}, Get, Hooks, }, - weights::{constants::RocksDbWeight, Weight}, + weights::Weight, }; use sp_runtime::{ @@ -645,7 +645,7 @@ impl Pallet { .saturating_add(T::DbWeight::get().writes(2)) } else { // 1 for get_current_epoch_info, 1 for get_epoch_length - T::DbWeight::get().reads(2u64).saturating_add(RocksDbWeight::get().writes(1)) + T::DbWeight::get().reads(2u64).saturating_add(T::DbWeight::get().writes(1)) } } } diff --git a/pallets/frequency-tx-payment/src/capacity_stable_weights.rs b/pallets/frequency-tx-payment/src/capacity_stable_weights.rs index a690e18c8d..7715bbf517 100644 --- a/pallets/frequency-tx-payment/src/capacity_stable_weights.rs +++ b/pallets/frequency-tx-payment/src/capacity_stable_weights.rs @@ -10,7 +10,7 @@ unused_imports )] -use frame_support::{traits::Get, weights::{Weight, constants::{RocksDbWeight, WEIGHT_REF_TIME_PER_NANOS}}}; +use frame_support::{traits::Get, weights::{Weight, constants::WEIGHT_REF_TIME_PER_NANOS}}; use sp_std::marker::PhantomData; /// The base fee for extrinsics is calculated by running benchmarks. @@ -291,8 +291,8 @@ impl WeightInfo for SubstrateWeight { Weight::from_parts(85_480_476, 12434) // Standard Error: 25_131 .saturating_add(Weight::from_parts(107_272, 0).saturating_mul(b.into())) - .saturating_add(RocksDbWeight::get().reads(3_u64)) - .saturating_add(RocksDbWeight::get().writes(3_u64)) + .saturating_add(T::DbWeight::get().reads(3_u64)) + .saturating_add(T::DbWeight::get().writes(3_u64)) } /// Storage: Msa PublicKeyToMsaId (r:1 w:0) /// Proof: Msa PublicKeyToMsaId (max_values: None, max_size: Some(48), added: 2523, mode: MaxEncodedLen) @@ -311,7 +311,7 @@ impl WeightInfo for SubstrateWeight { Weight::from_parts(95_748_064, 12434) // Standard Error: 9_821 .saturating_add(Weight::from_parts(212_118, 0).saturating_mul(b.into())) - .saturating_add(RocksDbWeight::get().reads(3_u64)) - .saturating_add(RocksDbWeight::get().writes(4_u64)) + .saturating_add(T::DbWeight::get().reads(3_u64)) + .saturating_add(T::DbWeight::get().writes(4_u64)) } } diff --git a/pallets/frequency-tx-payment/src/tests/mock.rs b/pallets/frequency-tx-payment/src/tests/mock.rs index 42a73a462f..3e2bcab165 100644 --- a/pallets/frequency-tx-payment/src/tests/mock.rs +++ b/pallets/frequency-tx-payment/src/tests/mock.rs @@ -22,7 +22,10 @@ use frame_support::{ use pallet_capacity::CapacityLedger; -pub use common_runtime::constants::{MAXIMUM_BLOCK_WEIGHT, NORMAL_DISPATCH_RATIO}; +pub use common_runtime::{ + constants::{MAXIMUM_BLOCK_WEIGHT, NORMAL_DISPATCH_RATIO}, + weights::rocksdb_weights::constants::RocksDbWeight, +}; use frame_support::weights::Weight; @@ -61,7 +64,7 @@ impl frame_system::Config for Test { type BaseCallFilter = frame_support::traits::Everything; type BlockWeights = BlockWeights; type BlockLength = (); - type DbWeight = (); + type DbWeight = RocksDbWeight; type RuntimeOrigin = RuntimeOrigin; type RuntimeCall = RuntimeCall; type Nonce = u64; diff --git a/pallets/frequency-tx-payment/src/tests/stable_weights_tests.rs b/pallets/frequency-tx-payment/src/tests/stable_weights_tests.rs index 9358e6f176..cb47682319 100644 --- a/pallets/frequency-tx-payment/src/tests/stable_weights_tests.rs +++ b/pallets/frequency-tx-payment/src/tests/stable_weights_tests.rs @@ -10,51 +10,51 @@ fn test_weights_are_stable() { ( "create_sponsored_account_with_delegation", SubstrateWeight::::create_sponsored_account_with_delegation(100), - 136951617, + 1130383617, 14946, ), ( "add_public_key_to_msa", SubstrateWeight::::add_public_key_to_msa(), - 177629000, + 1076501000, 18396, ), - ("grant_delegation", SubstrateWeight::::grant_delegation(100), 135218313, 14946), + ("grant_delegation", SubstrateWeight::::grant_delegation(100), 810962313, 14946), ( "add_onchain_message", SubstrateWeight::::add_onchain_message(100), - 174216930, + 437712930, 59148, ), - ("add_ipfs_message", SubstrateWeight::::add_ipfs_message(), 159242000, 48664), + ("add_ipfs_message", SubstrateWeight::::add_ipfs_message(), 375458000, 48664), ( "apply_item_actions", SubstrateWeight::::apply_item_actions(100), - 104869590, + 368365590, 45745, ), - ("upsert_page", SubstrateWeight::::upsert_page(100), 32356581, 12791), - ("delete_page", SubstrateWeight::::delete_page(), 37792000, 13950), + ("upsert_page", SubstrateWeight::::upsert_page(100), 295852581, 12791), + ("delete_page", SubstrateWeight::::delete_page(), 301288000, 13950), ( "apply_item_actions_with_signature", SubstrateWeight::::apply_item_actions_with_signature(100), - 160314012, + 376530012, 45752, ), ( "upsert_page_with_signature", SubstrateWeight::::upsert_page_with_signature(100), - 88433059, + 304649059, 12724, ), ( "delete_page_with_signature", SubstrateWeight::::delete_page_with_signature(), - 90631000, + 306847000, 13883, ), - ("claim_handle", SubstrateWeight::::claim_handle(100), 471207676, 12434), - ("change_handle", SubstrateWeight::::change_handle(100), 591959864, 12434), + ("claim_handle", SubstrateWeight::::claim_handle(100), 461175676, 12434), + ("change_handle", SubstrateWeight::::change_handle(100), 556303864, 12434), ]; for t in table { assert_eq!(t.1, Weight::from_parts(t.2, t.3), "{}", t.0); diff --git a/runtime/common/src/weights/mod.rs b/runtime/common/src/weights/mod.rs index 7f057497c5..d41b29d068 100644 --- a/runtime/common/src/weights/mod.rs +++ b/runtime/common/src/weights/mod.rs @@ -32,3 +32,4 @@ pub mod pallet_session; pub mod pallet_timestamp; pub mod pallet_treasury; pub mod pallet_utility; +pub mod rocksdb_weights; diff --git a/runtime/common/src/weights/rocksdb_weights.rs b/runtime/common/src/weights/rocksdb_weights.rs new file mode 100644 index 0000000000..ad2ed5ec7d --- /dev/null +++ b/runtime/common/src/weights/rocksdb_weights.rs @@ -0,0 +1,95 @@ +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev +//! DATE: 2024-08-22 (Y/M/D) +//! HOSTNAME: `ip-10-173-4-131`, CPU: `Intel(R) Xeon(R) Platinum 8375C CPU @ 2.90GHz` +//! +//! DATABASE: `RocksDb`, RUNTIME: `Frequency` +//! BLOCK-NUM: `BlockId::Number(4413540)` +//! SKIP-WRITE: `false`, SKIP-READ: `false`, WARMUPS: `2` +//! STATE-VERSION: `V1`, STATE-CACHE-SIZE: `` +//! WEIGHT-PATH: `` +//! METRIC: `Average`, WEIGHT-MUL: `1.3`, WEIGHT-ADD: `0` + +// Executed Command: +// ./target/release/frequency +// benchmark +// storage +// --state-version=1 +// --chain=frequency +// --base-path=/data +// --include-child-trees +// --warmups=2 +// --mul=1.3 + +/// Storage DB weights for the `Frequency` runtime and `RocksDb`. +pub mod constants { + use frame_support::weights::constants; + use sp_core::parameter_types; + use sp_weights::RuntimeDbWeight; + + parameter_types! { + /// By default, Substrate uses `RocksDB`, so this will be the weight used throughout + /// the runtime. + pub const RocksDbWeight: RuntimeDbWeight = RuntimeDbWeight { + // Time to read one storage item. + // Calculated by multiplying the *Average* of all values with `1.3` and adding `0`. + // + // Stats nanoseconds: + // Min, Max: 1_676, 3_967_371 + // Average: 36_369 + // Median: 36_876 + // Std-Dev: 10368.83 + // + // Percentiles nanoseconds: + // 99th: 60_542 + // 95th: 52_621 + // 75th: 43_407 + read: 47_280 * constants::WEIGHT_REF_TIME_PER_NANOS, + + // Time to write one storage item. + // Calculated by multiplying the *Average* of all values with `1.3` and adding `0`. + // + // Stats nanoseconds: + // Min, Max: 4_954, 87_545_132 + // Average: 57_212 + // Median: 62_141 + // Std-Dev: 60272.19 + // + // Percentiles nanoseconds: + // 99th: 101_820 + // 95th: 90_948 + // 75th: 75_800 + write: 74_376 * constants::WEIGHT_REF_TIME_PER_NANOS, + }; + } + + #[cfg(test)] + mod test_db_weights { + use super::constants::RocksDbWeight as W; + use sp_weights::constants; + + /// Checks that all weights exist and have sane values. + // NOTE: If this test fails but you are sure that the generated values are fine, + // you can delete it. + #[test] + fn bound() { + // At least 1 µs. + assert!( + W::get().reads(1).ref_time() >= constants::WEIGHT_REF_TIME_PER_MICROS, + "Read weight should be at least 1 µs." + ); + assert!( + W::get().writes(1).ref_time() >= constants::WEIGHT_REF_TIME_PER_MICROS, + "Write weight should be at least 1 µs." + ); + // At most 1 ms. + assert!( + W::get().reads(1).ref_time() <= constants::WEIGHT_REF_TIME_PER_MILLIS, + "Read weight should be at most 1 ms." + ); + assert!( + W::get().writes(1).ref_time() <= constants::WEIGHT_REF_TIME_PER_MILLIS, + "Write weight should be at most 1 ms." + ); + } + } +} diff --git a/runtime/frequency/src/lib.rs b/runtime/frequency/src/lib.rs index 2a690bdd80..b45e48b993 100644 --- a/runtime/frequency/src/lib.rs +++ b/runtime/frequency/src/lib.rs @@ -60,7 +60,7 @@ use frame_support::{ ConstBool, ConstU128, ConstU32, ConstU64, EitherOfDiverse, EqualPrivilegeOnly, InstanceFilter, LinearStoragePrice, }, - weights::{constants::RocksDbWeight, ConstantMultiplier, Weight}, + weights::{ConstantMultiplier, Weight}, Twox128, }; @@ -94,6 +94,7 @@ pub use common_runtime::{ }; use frame_support::traits::Contains; +use common_runtime::weights::rocksdb_weights::constants::RocksDbWeight; #[cfg(feature = "try-runtime")] use frame_support::traits::{TryStateSelect, UpgradeCheckSelect}; @@ -360,7 +361,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion { spec_name: create_runtime_str!("frequency"), impl_name: create_runtime_str!("frequency"), authoring_version: 1, - spec_version: 107, + spec_version: 108, impl_version: 0, apis: apis::RUNTIME_API_VERSIONS, transaction_version: 1, @@ -374,7 +375,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion { spec_name: create_runtime_str!("frequency-testnet"), impl_name: create_runtime_str!("frequency"), authoring_version: 1, - spec_version: 107, + spec_version: 108, impl_version: 0, apis: apis::RUNTIME_API_VERSIONS, transaction_version: 1,