Migrate pallet-preimage to benchmark v2 (paritytech#6277)

Part of: - paritytech#6202. --------- Co-authored-by: Giuseppe Re <[email protected]> Co-authored-by: command-bot <>
Krayt78 · Dec 18, 2024 · ccbe090 · ccbe090
1 parent cb9ed40
commit ccbe090
Show file tree

Hide file tree

Showing 2 changed files with 231 additions and 215 deletions.
diff --git a/substrate/frame/preimage/src/benchmarking.rs b/substrate/frame/preimage/src/benchmarking.rs
@@ -17,14 +17,13 @@
 
 //! Preimage pallet benchmarking.
 
-use super::*;
 use alloc::vec;
-use frame_benchmarking::v1::{account, benchmarks, whitelisted_caller, BenchmarkError};
+use frame_benchmarking::v2::*;
 use frame_support::assert_ok;
 use frame_system::RawOrigin;
 use sp_runtime::traits::Bounded;
 
-use crate::Pallet as Preimage;
+use crate::*;
 
 fn funded_account<T: Config>() -> T::AccountId {
 	let caller: T::AccountId = whitelisted_caller();
@@ -43,206 +42,225 @@ fn sized_preimage_and_hash<T: Config>(size: u32) -> (Vec<u8>, T::Hash) {
 	(preimage, hash)
 }
 
-benchmarks! {
+fn insert_old_unrequested<T: Config>(s: u32) -> <T as frame_system::Config>::Hash {
+	let acc = account("old", s, 0);
+	T::Currency::make_free_balance_be(&acc, BalanceOf::<T>::max_value() / 2u32.into());
+
+	// The preimage size does not matter here as it is not touched.
+	let preimage = s.to_le_bytes();
+	let hash = <T as frame_system::Config>::Hashing::hash(&preimage[..]);
+
+	#[allow(deprecated)]
+	StatusFor::<T>::insert(
+		&hash,
+		OldRequestStatus::Unrequested { deposit: (acc, 123u32.into()), len: preimage.len() as u32 },
+	);
+	hash
+}
+
+#[benchmarks]
+mod benchmarks {
+	use super::*;
+
 	// Expensive note - will reserve.
-	note_preimage {
-		let s in 0 .. MAX_SIZE;
+	#[benchmark]
+	fn note_preimage(s: Linear<0, MAX_SIZE>) {
 		let caller = funded_account::<T>();
 		let (preimage, hash) = sized_preimage_and_hash::<T>(s);
-	}: _(RawOrigin::Signed(caller), preimage)
-	verify {
-		assert!(Preimage::<T>::have_preimage(&hash));
+
+		#[extrinsic_call]
+		_(RawOrigin::Signed(caller), preimage);
+
+		assert!(Pallet::<T>::have_preimage(&hash));
 	}
+
 	// Cheap note - will not reserve since it was requested.
-	note_requested_preimage {
-		let s in 0 .. MAX_SIZE;
+	#[benchmark]
+	fn note_requested_preimage(s: Linear<0, MAX_SIZE>) {
 		let caller = funded_account::<T>();
 		let (preimage, hash) = sized_preimage_and_hash::<T>(s);
-		assert_ok!(Preimage::<T>::request_preimage(
+		assert_ok!(Pallet::<T>::request_preimage(
 			T::ManagerOrigin::try_successful_origin()
 				.expect("ManagerOrigin has no successful origin required for the benchmark"),
 			hash,
 		));
-	}: note_preimage(RawOrigin::Signed(caller), preimage)
-	verify {
-		assert!(Preimage::<T>::have_preimage(&hash));
+
+		#[extrinsic_call]
+		note_preimage(RawOrigin::Signed(caller), preimage);
+
+		assert!(Pallet::<T>::have_preimage(&hash));
 	}
+
 	// Cheap note - will not reserve since it's the manager.
-	note_no_deposit_preimage {
-		let s in 0 .. MAX_SIZE;
+	#[benchmark]
+	fn note_no_deposit_preimage(s: Linear<0, MAX_SIZE>) {
+		let o = T::ManagerOrigin::try_successful_origin()
+			.expect("ManagerOrigin has no successful origin required for the benchmark");
 		let (preimage, hash) = sized_preimage_and_hash::<T>(s);
-		assert_ok!(Preimage::<T>::request_preimage(
-			T::ManagerOrigin::try_successful_origin()
-				.expect("ManagerOrigin has no successful origin required for the benchmark"),
-			hash,
-		));
-	}: note_preimage<T::RuntimeOrigin>(
-		T::ManagerOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?,
-		preimage
-	) verify {
-		assert!(Preimage::<T>::have_preimage(&hash));
+		assert_ok!(Pallet::<T>::request_preimage(o.clone(), hash,));
+
+		#[extrinsic_call]
+		note_preimage(o as T::RuntimeOrigin, preimage);
+
+		assert!(Pallet::<T>::have_preimage(&hash));
 	}
 
 	// Expensive unnote - will unreserve.
-	unnote_preimage {
+	#[benchmark]
+	fn unnote_preimage() {
 		let caller = funded_account::<T>();
 		let (preimage, hash) = preimage_and_hash::<T>();
-		assert_ok!(Preimage::<T>::note_preimage(RawOrigin::Signed(caller.clone()).into(), preimage));
-	}: _(RawOrigin::Signed(caller), hash)
-	verify {
-		assert!(!Preimage::<T>::have_preimage(&hash));
+		assert_ok!(Pallet::<T>::note_preimage(RawOrigin::Signed(caller.clone()).into(), preimage));
+
+		#[extrinsic_call]
+		_(RawOrigin::Signed(caller), hash);
+
+		assert!(!Pallet::<T>::have_preimage(&hash));
 	}
+
 	// Cheap unnote - will not unreserve since there's no deposit held.
-	unnote_no_deposit_preimage {
+	#[benchmark]
+	fn unnote_no_deposit_preimage() {
+		let o = T::ManagerOrigin::try_successful_origin()
+			.expect("ManagerOrigin has no successful origin required for the benchmark");
 		let (preimage, hash) = preimage_and_hash::<T>();
-		assert_ok!(Preimage::<T>::note_preimage(
-			T::ManagerOrigin::try_successful_origin()
-				.expect("ManagerOrigin has no successful origin required for the benchmark"),
-			preimage,
-		));
-	}: unnote_preimage<T::RuntimeOrigin>(
-		T::ManagerOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?,
-		hash
-	) verify {
-		assert!(!Preimage::<T>::have_preimage(&hash));
+		assert_ok!(Pallet::<T>::note_preimage(o.clone(), preimage,));
+
+		#[extrinsic_call]
+		unnote_preimage(o as T::RuntimeOrigin, hash);
+
+		assert!(!Pallet::<T>::have_preimage(&hash));
 	}
 
 	// Expensive request - will unreserve the noter's deposit.
-	request_preimage {
+	#[benchmark]
+	fn request_preimage() {
+		let o = T::ManagerOrigin::try_successful_origin()
+			.expect("ManagerOrigin has no successful origin required for the benchmark");
 		let (preimage, hash) = preimage_and_hash::<T>();
 		let noter = funded_account::<T>();
-		assert_ok!(Preimage::<T>::note_preimage(RawOrigin::Signed(noter.clone()).into(), preimage));
-	}: _<T::RuntimeOrigin>(
-		T::ManagerOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?,
-		hash
-	) verify {
-		let ticket = TicketOf::<T>::new(&noter, Footprint { count: 1, size: MAX_SIZE as u64 }).unwrap();
-		let s = RequestStatus::Requested { maybe_ticket: Some((noter, ticket)), count: 1, maybe_len: Some(MAX_SIZE) };
+		assert_ok!(Pallet::<T>::note_preimage(RawOrigin::Signed(noter.clone()).into(), preimage));
+
+		#[extrinsic_call]
+		_(o as T::RuntimeOrigin, hash);
+
+		let ticket =
+			TicketOf::<T>::new(&noter, Footprint { count: 1, size: MAX_SIZE as u64 }).unwrap();
+		let s = RequestStatus::Requested {
+			maybe_ticket: Some((noter, ticket)),
+			count: 1,
+			maybe_len: Some(MAX_SIZE),
+		};
 		assert_eq!(RequestStatusFor::<T>::get(&hash), Some(s));
 	}
+
 	// Cheap request - would unreserve the deposit but none was held.
-	request_no_deposit_preimage {
+	#[benchmark]
+	fn request_no_deposit_preimage() {
+		let o = T::ManagerOrigin::try_successful_origin()
+			.expect("ManagerOrigin has no successful origin required for the benchmark");
 		let (preimage, hash) = preimage_and_hash::<T>();
-		assert_ok!(Preimage::<T>::note_preimage(
-			T::ManagerOrigin::try_successful_origin()
-				.expect("ManagerOrigin has no successful origin required for the benchmark"),
-			preimage,
-		));
-	}: request_preimage<T::RuntimeOrigin>(
-		T::ManagerOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?,
-		hash
-	) verify {
-		let s = RequestStatus::Requested { maybe_ticket: None, count: 2, maybe_len: Some(MAX_SIZE) };
+		assert_ok!(Pallet::<T>::note_preimage(o.clone(), preimage,));
+
+		#[extrinsic_call]
+		request_preimage(o as T::RuntimeOrigin, hash);
+
+		let s =
+			RequestStatus::Requested { maybe_ticket: None, count: 2, maybe_len: Some(MAX_SIZE) };
 		assert_eq!(RequestStatusFor::<T>::get(&hash), Some(s));
 	}
+
 	// Cheap request - the preimage is not yet noted, so deposit to unreserve.
-	request_unnoted_preimage {
+	#[benchmark]
+	fn request_unnoted_preimage() {
+		let o = T::ManagerOrigin::try_successful_origin()
+			.expect("ManagerOrigin has no successful origin required for the benchmark");
 		let (_, hash) = preimage_and_hash::<T>();
-	}: request_preimage<T::RuntimeOrigin>(
-		T::ManagerOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?,
-		hash
-	) verify {
+
+		#[extrinsic_call]
+		request_preimage(o as T::RuntimeOrigin, hash);
+
 		let s = RequestStatus::Requested { maybe_ticket: None, count: 1, maybe_len: None };
 		assert_eq!(RequestStatusFor::<T>::get(&hash), Some(s));
 	}
+
 	// Cheap request - the preimage is already requested, so just a counter bump.
-	request_requested_preimage {
+	#[benchmark]
+	fn request_requested_preimage() {
+		let o = T::ManagerOrigin::try_successful_origin()
+			.expect("ManagerOrigin has no successful origin required for the benchmark");
 		let (_, hash) = preimage_and_hash::<T>();
-		assert_ok!(Preimage::<T>::request_preimage(
-			T::ManagerOrigin::try_successful_origin()
-				.expect("ManagerOrigin has no successful origin required for the benchmark"),
-			hash,
-		));
-	}: request_preimage<T::RuntimeOrigin>(
-		T::ManagerOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?,
-		hash
-	) verify {
+		assert_ok!(Pallet::<T>::request_preimage(o.clone(), hash,));
+
+		#[extrinsic_call]
+		request_preimage(o as T::RuntimeOrigin, hash);
+
 		let s = RequestStatus::Requested { maybe_ticket: None, count: 2, maybe_len: None };
 		assert_eq!(RequestStatusFor::<T>::get(&hash), Some(s));
 	}
 
 	// Expensive unrequest - last reference and it's noted, so will destroy the preimage.
-	unrequest_preimage {
+	#[benchmark]
+	fn unrequest_preimage() {
+		let o = T::ManagerOrigin::try_successful_origin()
+			.expect("ManagerOrigin has no successful origin required for the benchmark");
 		let (preimage, hash) = preimage_and_hash::<T>();
-		assert_ok!(Preimage::<T>::request_preimage(
-			T::ManagerOrigin::try_successful_origin()
-				.expect("ManagerOrigin has no successful origin required for the benchmark"),
-			hash,
-		));
-		assert_ok!(Preimage::<T>::note_preimage(
-			T::ManagerOrigin::try_successful_origin()
-				.expect("ManagerOrigin has no successful origin required for the benchmark"),
-			preimage,
-		));
-	}: _<T::RuntimeOrigin>(
-		T::ManagerOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?,
-		hash
-	) verify {
+		assert_ok!(Pallet::<T>::request_preimage(o.clone(), hash,));
+		assert_ok!(Pallet::<T>::note_preimage(o.clone(), preimage));
+
+		#[extrinsic_call]
+		_(o as T::RuntimeOrigin, hash);
+
 		assert_eq!(RequestStatusFor::<T>::get(&hash), None);
 	}
+
 	// Cheap unrequest - last reference, but it's not noted.
-	unrequest_unnoted_preimage {
+	#[benchmark]
+	fn unrequest_unnoted_preimage() {
+		let o = T::ManagerOrigin::try_successful_origin()
+			.expect("ManagerOrigin has no successful origin required for the benchmark");
 		let (_, hash) = preimage_and_hash::<T>();
-		assert_ok!(Preimage::<T>::request_preimage(
-			T::ManagerOrigin::try_successful_origin()
-				.expect("ManagerOrigin has no successful origin required for the benchmark"),
-			hash,
-		));
-	}: unrequest_preimage<T::RuntimeOrigin>(
-		T::ManagerOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?,
-		hash
-	) verify {
+		assert_ok!(Pallet::<T>::request_preimage(o.clone(), hash,));
+
+		#[extrinsic_call]
+		unrequest_preimage(o as T::RuntimeOrigin, hash);
+
 		assert_eq!(RequestStatusFor::<T>::get(&hash), None);
 	}
+
 	// Cheap unrequest - not the last reference.
-	unrequest_multi_referenced_preimage {
+	#[benchmark]
+	fn unrequest_multi_referenced_preimage() {
+		let o = T::ManagerOrigin::try_successful_origin()
+			.expect("ManagerOrigin has no successful origin required for the benchmark");
 		let (_, hash) = preimage_and_hash::<T>();
-		assert_ok!(Preimage::<T>::request_preimage(
-			T::ManagerOrigin::try_successful_origin()
-				.expect("ManagerOrigin has no successful origin required for the benchmark"),
-			hash,
-		));
-		assert_ok!(Preimage::<T>::request_preimage(
-			T::ManagerOrigin::try_successful_origin()
-				.expect("ManagerOrigin has no successful origin required for the benchmark"),
-			hash,
-		));
-	}: unrequest_preimage<T::RuntimeOrigin>(
-		T::ManagerOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?,
-		hash
-	) verify {
+		assert_ok!(Pallet::<T>::request_preimage(o.clone(), hash,));
+		assert_ok!(Pallet::<T>::request_preimage(o.clone(), hash,));
+
+		#[extrinsic_call]
+		unrequest_preimage(o as T::RuntimeOrigin, hash);
+
 		let s = RequestStatus::Requested { maybe_ticket: None, count: 1, maybe_len: None };
 		assert_eq!(RequestStatusFor::<T>::get(&hash), Some(s));
 	}
 
-	ensure_updated {
-		let n in 1..MAX_HASH_UPGRADE_BULK_COUNT;
-
+	#[benchmark]
+	fn ensure_updated(n: Linear<1, MAX_HASH_UPGRADE_BULK_COUNT>) {
 		let caller = funded_account::<T>();
 		let hashes = (0..n).map(|i| insert_old_unrequested::<T>(i)).collect::<Vec<_>>();
-	}: _(RawOrigin::Signed(caller), hashes)
-	verify {
+
+		#[extrinsic_call]
+		_(RawOrigin::Signed(caller), hashes);
+
 		assert_eq!(RequestStatusFor::<T>::iter_keys().count(), n as usize);
 		#[allow(deprecated)]
 		let c = StatusFor::<T>::iter_keys().count();
 		assert_eq!(c, 0);
 	}
 
-	impl_benchmark_test_suite!(Preimage, crate::mock::new_test_ext(), crate::mock::Test);
-}
-
-fn insert_old_unrequested<T: Config>(s: u32) -> <T as frame_system::Config>::Hash {
-	let acc = account("old", s, 0);
-	T::Currency::make_free_balance_be(&acc, BalanceOf::<T>::max_value() / 2u32.into());
-
-	// The preimage size does not matter here as it is not touched.
-	let preimage = s.to_le_bytes();
-	let hash = <T as frame_system::Config>::Hashing::hash(&preimage[..]);
-
-	#[allow(deprecated)]
-	StatusFor::<T>::insert(
-		&hash,
-		OldRequestStatus::Unrequested { deposit: (acc, 123u32.into()), len: preimage.len() as u32 },
-	);
-	hash
+	impl_benchmark_test_suite! {
+		Pallet,
+		mock::new_test_ext(),
+		mock::Test
+	}
 }