pezkuwichain/pezkuwi-subxt
1
0
Fork 0
mirror of https://github.com/pezkuwichain/pezkuwi-subxt.git synced 2026-06-13 11:41:04 +00:00
Code Issues Packages Projects Releases Wiki Activity

Benchmarking: Add pov_mode to V2 syntax (#3616)

Browse Source 
Changes:
- Port the `pov_mode` attribute from the V1 syntax to V2
- Update `pallet-whitelist` and `frame-benchmarking-pallet-pov`

Follow up: also allow this attribute on top-level benchmark modules.

---------

Signed-off-by: Oliver Tale-Yazdi <oliver.tale-yazdi@parity.io>
Co-authored-by: command-bot <>
This commit is contained in:
Oliver Tale-Yazdi
2024-03-19 13:35:22 +02:00
committed by GitHub
parent 430ad2f561
commit abd3f0c49a
18 changed files with 1086 additions and 602 deletions
Download Patch File Download Diff File Expand all files Collapse all files
substrate/frame/benchmarking/pov/src/benchmarking.rs
+236 -178
View File
@@ -21,54 +21,78 @@
use super::*;
use frame_benchmarking::v2::*;
use frame_support::traits::UnfilteredDispatchable;
use frame_system::{Pallet as System, RawOrigin};
use sp_runtime::traits::Hash;
frame_benchmarking::benchmarks! {
storage_single_value_read {
#[benchmarks]
mod benchmarks {
use super::*;
#[benchmark]
fn storage_single_value_read() {
Value::<T>::put(123);
}: {
assert_eq!(Value::<T>::get(), Some(123));
#[block]
{
assert_eq!(Value::<T>::get(), Some(123));
}
}
#[pov_mode = Ignored]
storage_single_value_ignored_read {
#[benchmark(pov_mode = Ignored)]
fn storage_single_value_ignored_read() {
Value::<T>::put(123);
}: {
assert_eq!(Value::<T>::get(), Some(123));
#[block]
{
assert_eq!(Value::<T>::get(), Some(123));
}
}
#[pov_mode = MaxEncodedLen {
#[benchmark(pov_mode = MaxEncodedLen {
Pov::Value2: Ignored
}]
storage_single_value_ignored_some_read {
})]
fn storage_single_value_ignored_some_read() {
Value::<T>::put(123);
Value2::<T>::put(123);
}: {
assert_eq!(Value::<T>::get(), Some(123));
assert_eq!(Value2::<T>::get(), Some(123));
#[block]
{
assert_eq!(Value::<T>::get(), Some(123));
assert_eq!(Value2::<T>::get(), Some(123));
}
}
storage_single_value_read_twice {
#[benchmark]
fn storage_single_value_read_twice() {
Value::<T>::put(123);
}: {
assert_eq!(Value::<T>::get(), Some(123));
#[block]
{
assert_eq!(Value::<T>::get(), Some(123));
assert_eq!(Value::<T>::get(), Some(123));
}
}
#[benchmark]
fn storage_single_value_write() {
#[block]
{
Value::<T>::put(123);
}
assert_eq!(Value::<T>::get(), Some(123));
}
storage_single_value_write {
}: {
#[benchmark]
fn storage_single_value_kill() {
Value::<T>::put(123);
} verify {
assert_eq!(Value::<T>::get(), Some(123));
}
storage_single_value_kill {
Value::<T>::put(123);
}: {
Value::<T>::kill();
} verify {
#[block]
{
Value::<T>::kill();
}
assert!(!Value::<T>::exists());
}
@@ -78,263 +102,297 @@ frame_benchmarking::benchmarks! {
// created. Then the one value is read from the map. This demonstrates that the number of other
// nodes in the Trie influences the proof size. The number of inserted nodes can be interpreted
// as the number of `StorageMap`/`StorageValue` in the whole runtime.
#[pov_mode = Measured]
storage_1m_map_read_one_value_two_additional_layers {
(0..(1<<10)).for_each(|i| Map1M::<T>::insert(i, i));
#[benchmark(pov_mode = Measured)]
fn storage_1m_map_read_one_value_two_additional_layers() {
(0..(1 << 10)).for_each(|i| Map1M::<T>::insert(i, i));
// Assume there are 16-256 other storage items.
(0..(1u32<<4)).for_each(|i| {
(0..(1u32 << 4)).for_each(|i| {
let k = T::Hashing::hash(&i.to_be_bytes());
frame_support::storage::unhashed::put(k.as_ref(), &i);
});
}: {
assert_eq!(Map1M::<T>::get(1<<9), Some(1<<9));
#[block]
{
assert_eq!(Map1M::<T>::get(1 << 9), Some(1 << 9));
}
}
#[pov_mode = Measured]
storage_1m_map_read_one_value_three_additional_layers {
(0..(1<<10)).for_each(|i| Map1M::<T>::insert(i, i));
#[benchmark(pov_mode = Measured)]
fn storage_1m_map_read_one_value_three_additional_layers() {
(0..(1 << 10)).for_each(|i| Map1M::<T>::insert(i, i));
// Assume there are 256-4096 other storage items.
(0..(1u32<<8)).for_each(|i| {
(0..(1u32 << 8)).for_each(|i| {
let k = T::Hashing::hash(&i.to_be_bytes());
frame_support::storage::unhashed::put(k.as_ref(), &i);
});
}: {
assert_eq!(Map1M::<T>::get(1<<9), Some(1<<9));
#[block]
{
assert_eq!(Map1M::<T>::get(1 << 9), Some(1 << 9));
}
}
#[pov_mode = Measured]
storage_1m_map_read_one_value_four_additional_layers {
(0..(1<<10)).for_each(|i| Map1M::<T>::insert(i, i));
#[benchmark(pov_mode = Measured)]
fn storage_1m_map_read_one_value_four_additional_layers() {
(0..(1 << 10)).for_each(|i| Map1M::<T>::insert(i, i));
// Assume there are 4096-65536 other storage items.
(0..(1u32<<12)).for_each(|i| {
(0..(1u32 << 12)).for_each(|i| {
let k = T::Hashing::hash(&i.to_be_bytes());
frame_support::storage::unhashed::put(k.as_ref(), &i);
});
}: {
assert_eq!(Map1M::<T>::get(1<<9), Some(1<<9));
#[block]
{
assert_eq!(Map1M::<T>::get(1 << 9), Some(1 << 9));
}
}
// Reads from both storage maps each `n` and `m` times. Should result in two linear components.
storage_map_read_per_component {
let n in 0 .. 100;
let m in 0 .. 100;
#[benchmark]
fn storage_map_read_per_component(n: Linear<0, 100>, m: Linear<0, 100>) {
(0..m * 10).for_each(|i| Map1M::<T>::insert(i, i));
(0..n * 10).for_each(|i| Map16M::<T>::insert(i, i));
(0..m*10).for_each(|i| Map1M::<T>::insert(i, i));
(0..n*10).for_each(|i| Map16M::<T>::insert(i, i));
}: {
(0..m).for_each(|i|
assert_eq!(Map1M::<T>::get(i*10), Some(i*10)));
(0..n).for_each(|i|
assert_eq!(Map16M::<T>::get(i*10), Some(i*10)));
#[block]
{
(0..m).for_each(|i| assert_eq!(Map1M::<T>::get(i * 10), Some(i * 10)));
(0..n).for_each(|i| assert_eq!(Map16M::<T>::get(i * 10), Some(i * 10)));
}
}
#[pov_mode = MaxEncodedLen {
#[benchmark(pov_mode = MaxEncodedLen {
Pov::Map1M: Ignored
}]
storage_map_read_per_component_one_ignored {
let n in 0 .. 100;
let m in 0 .. 100;
})]
fn storage_map_read_per_component_one_ignored(n: Linear<0, 100>, m: Linear<0, 100>) {
(0..m * 10).for_each(|i| Map1M::<T>::insert(i, i));
(0..n * 10).for_each(|i| Map16M::<T>::insert(i, i));
(0..m*10).for_each(|i| Map1M::<T>::insert(i, i));
(0..n*10).for_each(|i| Map16M::<T>::insert(i, i));
}: {
(0..m).for_each(|i|
assert_eq!(Map1M::<T>::get(i*10), Some(i*10)));
(0..n).for_each(|i|
assert_eq!(Map16M::<T>::get(i*10), Some(i*10)));
#[block]
{
(0..m).for_each(|i| assert_eq!(Map1M::<T>::get(i * 10), Some(i * 10)));
(0..n).for_each(|i| assert_eq!(Map16M::<T>::get(i * 10), Some(i * 10)));
}
}
// Reads the same value from a storage map. Should not result in a component.
storage_1m_map_one_entry_repeated_read {
let n in 0 .. 100;
#[benchmark]
fn storage_1m_map_one_entry_repeated_read(n: Linear<0, 100>) {
Map1M::<T>::insert(0, 0);
}: {
(0..n).for_each(|i|
assert_eq!(Map1M::<T>::get(0), Some(0)));
#[block]
{
(0..n).for_each(|_| assert_eq!(Map1M::<T>::get(0), Some(0)));
}
}
// Reads the same values from a storage map. Should result in a `1x` linear component.
storage_1m_map_multiple_entry_repeated_read {
let n in 0 .. 100;
#[benchmark]
fn storage_1m_map_multiple_entry_repeated_read(n: Linear<0, 100>) {
(0..n).for_each(|i| Map1M::<T>::insert(i, i));
}: {
(0..n).for_each(|i| {
// Reading the same value 10 times does nothing.
(0..10).for_each(|j|
assert_eq!(Map1M::<T>::get(i), Some(i)));
});
#[block]
{
(0..n).for_each(|i| {
// Reading the same value 10 times does nothing.
(0..10).for_each(|_| assert_eq!(Map1M::<T>::get(i), Some(i)));
});
}
}
storage_1m_double_map_read_per_component {
let n in 0 .. 1024;
(0..(1<<10)).for_each(|i| DoubleMap1M::<T>::insert(i, i, i));
}: {
(0..n).for_each(|i|
assert_eq!(DoubleMap1M::<T>::get(i, i), Some(i)));
#[benchmark]
fn storage_1m_double_map_read_per_component(n: Linear<0, 1024>) {
(0..(1 << 10)).for_each(|i| DoubleMap1M::<T>::insert(i, i, i));
#[block]
{
(0..n).for_each(|i| assert_eq!(DoubleMap1M::<T>::get(i, i), Some(i)));
}
}
storage_value_bounded_read {
}: {
assert!(BoundedValue::<T>::get().is_none());
#[benchmark]
fn storage_value_bounded_read() {
#[block]
{
assert!(BoundedValue::<T>::get().is_none());
}
}
// Reading unbounded values will produce no mathematical worst case PoV size for this component.
storage_value_unbounded_read {
}: {
assert!(UnboundedValue::<T>::get().is_none());
#[benchmark]
fn storage_value_unbounded_read() {
#[block]
{
assert!(UnboundedValue::<T>::get().is_none());
}
}
#[pov_mode = Ignored]
storage_value_unbounded_ignored_read {
}: {
assert!(UnboundedValue::<T>::get().is_none());
#[benchmark(pov_mode = Ignored)]
fn storage_value_unbounded_ignored_read() {
#[block]
{
assert!(UnboundedValue::<T>::get().is_none());
}
}
// Same as above, but we still expect a mathematical worst case PoV size for the bounded one.
storage_value_bounded_and_unbounded_read {
#[benchmark]
fn storage_value_bounded_and_unbounded_read() {
(0..1024).for_each(|i| Map1M::<T>::insert(i, i));
}: {
assert!(UnboundedValue::<T>::get().is_none());
assert!(BoundedValue::<T>::get().is_none());
#[block]
{
assert!(UnboundedValue::<T>::get().is_none());
assert!(BoundedValue::<T>::get().is_none());
}
}
#[pov_mode = Measured]
measured_storage_value_read_linear_size {
let l in 0 .. 1<<22;
#[benchmark(pov_mode = Measured)]
fn measured_storage_value_read_linear_size(l: Linear<0, { 1 << 22 }>) {
let v: sp_runtime::BoundedVec<u8, _> = sp_std::vec![0u8; l as usize].try_into().unwrap();
LargeValue::<T>::put(&v);
}: {
assert!(LargeValue::<T>::get().is_some());
#[block]
{
assert!(LargeValue::<T>::get().is_some());
}
}
#[pov_mode = MaxEncodedLen]
mel_storage_value_read_linear_size {
let l in 0 .. 1<<22;
#[benchmark(pov_mode = MaxEncodedLen)]
fn mel_storage_value_read_linear_size(l: Linear<0, { 1 << 22 }>) {
let v: sp_runtime::BoundedVec<u8, _> = sp_std::vec![0u8; l as usize].try_into().unwrap();
LargeValue::<T>::put(&v);
}: {
assert!(LargeValue::<T>::get().is_some());
#[block]
{
assert!(LargeValue::<T>::get().is_some());
}
}
#[pov_mode = Measured]
measured_storage_double_value_read_linear_size {
let l in 0 .. 1<<22;
#[benchmark(pov_mode = Measured)]
fn measured_storage_double_value_read_linear_size(l: Linear<0, { 1 << 22 }>) {
let v: sp_runtime::BoundedVec<u8, _> = sp_std::vec![0u8; l as usize].try_into().unwrap();
LargeValue::<T>::put(&v);
LargeValue2::<T>::put(&v);
}: {
assert!(LargeValue::<T>::get().is_some());
assert!(LargeValue2::<T>::get().is_some());
#[block]
{
assert!(LargeValue::<T>::get().is_some());
assert!(LargeValue2::<T>::get().is_some());
}
}
#[pov_mode = MaxEncodedLen]
mel_storage_double_value_read_linear_size {
let l in 0 .. 1<<22;
#[benchmark(pov_mode = MaxEncodedLen)]
fn mel_storage_double_value_read_linear_size(l: Linear<0, { 1 << 22 }>) {
let v: sp_runtime::BoundedVec<u8, _> = sp_std::vec![0u8; l as usize].try_into().unwrap();
LargeValue::<T>::put(&v);
LargeValue2::<T>::put(&v);
}: {
assert!(LargeValue::<T>::get().is_some());
assert!(LargeValue2::<T>::get().is_some());
#[block]
{
assert!(LargeValue::<T>::get().is_some());
assert!(LargeValue2::<T>::get().is_some());
}
}
#[pov_mode = MaxEncodedLen {
#[benchmark(pov_mode = MaxEncodedLen {
Pov::LargeValue2: Measured
}]
mel_mixed_storage_double_value_read_linear_size {
let l in 0 .. 1<<22;
})]
fn mel_mixed_storage_double_value_read_linear_size(l: Linear<0, { 1 << 22 }>) {
let v: sp_runtime::BoundedVec<u8, _> = sp_std::vec![0u8; l as usize].try_into().unwrap();
LargeValue::<T>::put(&v);
LargeValue2::<T>::put(&v);
}: {
assert!(LargeValue::<T>::get().is_some());
assert!(LargeValue2::<T>::get().is_some());
#[block]
{
assert!(LargeValue::<T>::get().is_some());
assert!(LargeValue2::<T>::get().is_some());
}
}
#[pov_mode = Measured {
#[benchmark(pov_mode = Measured {
Pov::LargeValue2: MaxEncodedLen
}]
measured_mixed_storage_double_value_read_linear_size {
let l in 0 .. 1<<22;
})]
fn measured_mixed_storage_double_value_read_linear_size(l: Linear<0, { 1 << 22 }>) {
let v: sp_runtime::BoundedVec<u8, _> = sp_std::vec![0u8; l as usize].try_into().unwrap();
LargeValue::<T>::put(&v);
LargeValue2::<T>::put(&v);
}: {
assert!(LargeValue::<T>::get().is_some());
assert!(LargeValue2::<T>::get().is_some());
#[block]
{
assert!(LargeValue::<T>::get().is_some());
assert!(LargeValue2::<T>::get().is_some());
}
}
#[pov_mode = Measured]
storage_map_unbounded_both_measured_read {
let i in 0 .. 1000;
#[benchmark(pov_mode = Measured)]
fn storage_map_unbounded_both_measured_read(i: Linear<0, 1000>) {
UnboundedMap::<T>::insert(i, sp_std::vec![0; i as usize]);
UnboundedMap2::<T>::insert(i, sp_std::vec![0; i as usize]);
}: {
assert!(UnboundedMap::<T>::get(i).is_some());
assert!(UnboundedMap2::<T>::get(i).is_some());
#[block]
{
assert!(UnboundedMap::<T>::get(i).is_some());
assert!(UnboundedMap2::<T>::get(i).is_some());
}
}
#[pov_mode = MaxEncodedLen {
#[benchmark(pov_mode = MaxEncodedLen {
Pov::UnboundedMap: Measured
}]
storage_map_partial_unbounded_read {
let i in 0 .. 1000;
})]
fn storage_map_partial_unbounded_read(i: Linear<0, 1000>) {
Map1M::<T>::insert(i, 0);
UnboundedMap::<T>::insert(i, sp_std::vec![0; i as usize]);
}: {
assert!(Map1M::<T>::get(i).is_some());
assert!(UnboundedMap::<T>::get(i).is_some());
#[block]
{
assert!(Map1M::<T>::get(i).is_some());
assert!(UnboundedMap::<T>::get(i).is_some());
}
}
#[pov_mode = MaxEncodedLen {
#[benchmark(pov_mode = MaxEncodedLen {
Pov::UnboundedMap: Ignored
}]
storage_map_partial_unbounded_ignored_read {
let i in 0 .. 1000;
})]
fn storage_map_partial_unbounded_ignored_read(i: Linear<0, 1000>) {
Map1M::<T>::insert(i, 0);
UnboundedMap::<T>::insert(i, sp_std::vec![0; i as usize]);
}: {
assert!(Map1M::<T>::get(i).is_some());
assert!(UnboundedMap::<T>::get(i).is_some());
#[block]
{
assert!(Map1M::<T>::get(i).is_some());
assert!(UnboundedMap::<T>::get(i).is_some());
}
}
// Emitting an event will not incur any PoV.
emit_event {
#[benchmark]
fn emit_event() {
// Emit a single event.
let call = Call::<T>::emit_event { };
}: { call.dispatch_bypass_filter(RawOrigin::Root.into()).unwrap(); }
verify {
let call = Call::<T>::emit_event {};
#[block]
{
call.dispatch_bypass_filter(RawOrigin::Root.into()).unwrap();
}
assert_eq!(System::<T>::events().len(), 1);
}
// A No-OP will not incur any PoV.
noop {
let call = Call::<T>::noop { };
}: {
call.dispatch_bypass_filter(RawOrigin::Root.into()).unwrap();
#[benchmark]
fn noop() {
let call = Call::<T>::noop {};
#[block]
{
call.dispatch_bypass_filter(RawOrigin::Root.into()).unwrap();
}
}
storage_iteration {
#[benchmark]
fn storage_iteration() {
for i in 0..65000 {
UnboundedMapTwox::<T>::insert(i, sp_std::vec![0; 64]);
}
}: {
for (key, value) in UnboundedMapTwox::<T>::iter() {
unsafe {
core::ptr::read_volatile(&key);
core::ptr::read_volatile(value.as_ptr());
#[block]
{
for (key, value) in UnboundedMapTwox::<T>::iter() {
unsafe {
core::ptr::read_volatile(&key);
core::ptr::read_volatile(value.as_ptr());
}
}
}
}
impl_benchmark_test_suite!(
Pallet,
mock::new_test_ext(),
mock::Test,
);
impl_benchmark_test_suite!(Pallet, super::mock::new_test_ext(), super::mock::Test,);
}
#[cfg(test)]
substrate/frame/benchmarking/pov/src/weights.rs
Generated
+354 -356
View File
File diff suppressed because it is too large Load Diff