referrerpolicy=no-referrer-when-downgrade
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

// Copyright (C) Parity Technologies (UK) Ltd.
// This file is part of Parity Bridges Common.

// Parity Bridges Common is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// Parity Bridges Common is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with Parity Bridges Common.  If not, see <http://www.gnu.org/licenses/>.

//! Parachains finality pallet benchmarking.

use crate::{
	weights_ext::DEFAULT_PARACHAIN_HEAD_SIZE, Call, RelayBlockHash, RelayBlockHasher,
	RelayBlockNumber,
};

use bp_polkadot_core::parachains::{ParaHash, ParaHeadsProof, ParaId};
use bp_runtime::UnverifiedStorageProofParams;
use frame_benchmarking::{account, benchmarks_instance_pallet};
use frame_system::RawOrigin;
use sp_std::prelude::*;

/// Pallet we're benchmarking here.
pub struct Pallet<T: Config<I>, I: 'static = ()>(crate::Pallet<T, I>);

/// Trait that must be implemented by runtime to benchmark the parachains finality pallet.
pub trait Config<I: 'static>: crate::Config<I> {
	/// Returns vector of supported parachains.
	fn parachains() -> Vec<ParaId>;
	/// Generate parachain heads proof and prepare environment for verifying this proof.
	fn prepare_parachain_heads_proof(
		parachains: &[ParaId],
		parachain_head_size: u32,
		proof_params: UnverifiedStorageProofParams,
	) -> (RelayBlockNumber, RelayBlockHash, ParaHeadsProof, Vec<(ParaId, ParaHash)>);
}

benchmarks_instance_pallet! {
	where_clause {
		where
			<T as pallet_bridge_grandpa::Config<T::BridgesGrandpaPalletInstance>>::BridgedChain:
				bp_runtime::Chain<
					BlockNumber = RelayBlockNumber,
					Hash = RelayBlockHash,
					Hasher = RelayBlockHasher,
				>,
	}

	// Benchmark `submit_parachain_heads` extrinsic with different number of parachains.
	submit_parachain_heads_with_n_parachains {
		let p in 1..(T::parachains().len() + 1) as u32;

		let sender = account("sender", 0, 0);
		let mut parachains = T::parachains();
		let _ = if p <= parachains.len() as u32 {
			parachains.split_off(p as usize)
		} else {
			Default::default()
		};
		log::trace!(target: crate::LOG_TARGET, "=== {:?}", parachains.len());
		let (relay_block_number, relay_block_hash, parachain_heads_proof, parachains_heads) = T::prepare_parachain_heads_proof(
			&parachains,
			DEFAULT_PARACHAIN_HEAD_SIZE,
			UnverifiedStorageProofParams::default(),
		);
		let at_relay_block = (relay_block_number, relay_block_hash);
	}: submit_parachain_heads(RawOrigin::Signed(sender), at_relay_block, parachains_heads, parachain_heads_proof)
	verify {
		for parachain in parachains {
			assert!(crate::Pallet::<T, I>::best_parachain_head(parachain).is_some());
		}
	}

	// Benchmark `submit_parachain_heads` extrinsic with 1kb proof size.
	submit_parachain_heads_with_1kb_proof {
		let sender = account("sender", 0, 0);
		let parachains = vec![T::parachains()[0]];
		let (relay_block_number, relay_block_hash, parachain_heads_proof, parachains_heads) = T::prepare_parachain_heads_proof(
			&parachains,
			DEFAULT_PARACHAIN_HEAD_SIZE,
			UnverifiedStorageProofParams::from_db_size(1024),
		);
		let at_relay_block = (relay_block_number, relay_block_hash);
	}: submit_parachain_heads(RawOrigin::Signed(sender), at_relay_block, parachains_heads, parachain_heads_proof)
	verify {
		for parachain in parachains {
			assert!(crate::Pallet::<T, I>::best_parachain_head(parachain).is_some());
		}
	}

	// Benchmark `submit_parachain_heads` extrinsic with 16kb proof size.
	submit_parachain_heads_with_16kb_proof {
		let sender = account("sender", 0, 0);
		let parachains = vec![T::parachains()[0]];
		let (relay_block_number, relay_block_hash, parachain_heads_proof, parachains_heads) = T::prepare_parachain_heads_proof(
			&parachains,
			DEFAULT_PARACHAIN_HEAD_SIZE,
			UnverifiedStorageProofParams::from_db_size(16 * 1024),
		);
		let at_relay_block = (relay_block_number, relay_block_hash);
	}: submit_parachain_heads(RawOrigin::Signed(sender), at_relay_block, parachains_heads, parachain_heads_proof)
	verify {
		for parachain in parachains {
			assert!(crate::Pallet::<T, I>::best_parachain_head(parachain).is_some());
		}
	}

	impl_benchmark_test_suite!(Pallet, crate::mock::new_test_ext(), crate::mock::TestRuntime)
}