Renames API

cumulus/xcm/xcm-emulator/src/lib.rs

@@ -1028,7 +1028,7 @@ macro_rules! decl_test_networks {
 					use $crate::{Bounded, ProcessMessage, WeightMeter};
 					use sp_core::Encode;
 					while let Some((from_para_id, msg)) = $crate::UPWARD_MESSAGES.with(|b| b.borrow_mut().get_mut(Self::name()).unwrap().pop_front()) {
-						let mut weight_meter = WeightMeter::max_limit();
+						let mut weight_meter = WeightMeter::new();
 						<$relay_chain>::ext_wrapper(|| {
 							let _ =  <$relay_chain as RelayChain>::MessageProcessor::process_message(
 								&msg[..],

polkadot/xcm/xcm-builder/src/process_xcm_message.rs

@@ -110,7 +110,7 @@ mod tests {
 
 			// Errors if we stay below a weight limit of 1000.
 			for i in 0..10 {
-				let meter = &mut WeightMeter::from_limit((i * 10).into());
+				let meter = &mut WeightMeter::with_limit((i * 10).into());
 				let mut id = [0; 32];
 				assert_err!(
 					Processor::process_message(msg, ORIGIN, meter, &mut id),
@@ -120,7 +120,7 @@ mod tests {
 			}
 
 			// Works with a limit of 1000.
-			let meter = &mut WeightMeter::from_limit(1000.into());
+			let meter = &mut WeightMeter::with_limit(1000.into());
 			let mut id = [0; 32];
 			assert_ok!(Processor::process_message(msg, ORIGIN, meter, &mut id));
 			assert_eq!(meter.consumed(), 1000.into());
@@ -150,6 +150,6 @@ mod tests {
 	}
 
 	fn process_raw(raw: &[u8]) -> Result<bool, ProcessMessageError> {
-		Processor::process_message(raw, ORIGIN, &mut WeightMeter::max_limit(), &mut [0; 32])
+		Processor::process_message(raw, ORIGIN, &mut WeightMeter::new(), &mut [0; 32])
 	}
 }

polkadot/xcm/xcm-simulator/src/lib.rs

@@ -324,7 +324,7 @@ macro_rules! decl_test_network {
 						let mut _id = [0; 32];
 						let r = <$relay_chain>::process_message(
 							encoded.as_slice(), para_id,
-							&mut $crate::WeightMeter::max_limit(),
+							&mut $crate::WeightMeter::new(),
 							&mut _id,
 						);
 						match r {

substrate/frame/broker/src/tick_impls.rs

@@ -41,7 +41,7 @@ impl<T: Config> Pallet<T> {
 			_ => return Weight::zero(),
 		};
 
-		let mut meter = WeightMeter::max_limit();
+		let mut meter = WeightMeter::new();
 
 		if Self::process_core_count(&mut status) {
 			meter.consume(T::WeightInfo::process_core_count(status.core_count.into()));

substrate/frame/glutton/src/lib.rs

@@ -188,7 +188,7 @@ pub mod pallet {
 		}
 
 		fn on_idle(_: BlockNumberFor<T>, remaining_weight: Weight) -> Weight {
-			let mut meter = WeightMeter::from_limit(remaining_weight);
+			let mut meter = WeightMeter::with_limit(remaining_weight);
 			if meter.try_consume(T::WeightInfo::empty_on_idle()).is_err() {
 				return T::WeightInfo::empty_on_idle()
 			}
@@ -197,7 +197,7 @@ pub mod pallet {
 				Storage::<T>::get().saturating_mul_int(meter.remaining().proof_size());
 			let computation_weight_limit =
 				Compute::<T>::get().saturating_mul_int(meter.remaining().ref_time());
-			let mut meter = WeightMeter::from_limit(Weight::from_parts(
+			let mut meter = WeightMeter::with_limit(Weight::from_parts(
 				computation_weight_limit,
 				proof_size_limit,
 			));

substrate/frame/glutton/src/tests.rs

@@ -252,7 +252,7 @@ fn on_idle_weight_over_unity_is_close_enough_works() {
 fn waste_at_most_ref_time_weight_close_enough() {
 	new_test_ext().execute_with(|| {
 		let mut meter =
-			WeightMeter::from_limit(Weight::from_parts(WEIGHT_REF_TIME_PER_SECOND, u64::MAX));
+			WeightMeter::with_limit(Weight::from_parts(WEIGHT_REF_TIME_PER_SECOND, u64::MAX));
 		// Over-spending fails defensively.
 		Glutton::waste_at_most_ref_time(&mut meter);
 
@@ -269,7 +269,7 @@ fn waste_at_most_ref_time_weight_close_enough() {
 fn waste_at_most_proof_size_weight_close_enough() {
 	new_test_ext().execute_with(|| {
 		let mut meter =
-			WeightMeter::from_limit(Weight::from_parts(u64::MAX, WEIGHT_PROOF_SIZE_PER_MB * 5));
+			WeightMeter::with_limit(Weight::from_parts(u64::MAX, WEIGHT_PROOF_SIZE_PER_MB * 5));
 		// Over-spending fails defensively.
 		Glutton::waste_at_most_proof_size(&mut meter);
 

substrate/frame/message-queue/src/benchmarking.rs

@@ -78,7 +78,7 @@ mod benchmarks {
 	fn service_queue_base() {
 		#[block]
 		{
-			MessageQueue::<T>::service_queue(0.into(), &mut WeightMeter::max_limit(), Weight::MAX);
+			MessageQueue::<T>::service_queue(0.into(), &mut WeightMeter::new(), Weight::MAX);
 		}
 	}
 
@@ -89,7 +89,7 @@ mod benchmarks {
 		let page = PageOf::<T>::default();
 		Pages::<T>::insert(&origin, 0, &page);
 		let mut book_state = single_page_book::<T>();
-		let mut meter = WeightMeter::max_limit();
+		let mut meter = WeightMeter::new();
 		let limit = Weight::MAX;
 
 		#[block]
@@ -108,7 +108,7 @@ mod benchmarks {
 		page.remaining = 1.into();
 		Pages::<T>::insert(&origin, 0, &page);
 		let mut book_state = single_page_book::<T>();
-		let mut meter = WeightMeter::max_limit();
+		let mut meter = WeightMeter::new();
 		let limit = Weight::MAX;
 
 		#[block]
@@ -124,7 +124,7 @@ mod benchmarks {
 		let mut page = page::<T>(&msg.clone());
 		let mut book = book_for::<T>(&page);
 		assert!(page.peek_first().is_some(), "There is one message");
-		let mut weight = WeightMeter::max_limit();
+		let mut weight = WeightMeter::new();
 
 		#[block]
 		{
@@ -158,7 +158,7 @@ mod benchmarks {
 	#[benchmark]
 	fn bump_service_head() {
 		setup_bump_service_head::<T>(0.into(), 10.into());
-		let mut weight = WeightMeter::max_limit();
+		let mut weight = WeightMeter::new();
 
 		#[block]
 		{

substrate/frame/message-queue/src/lib.rs

@@ -832,7 +832,7 @@ impl<T: Config> Pallet<T> {
 		);
 		ensure!(!is_processed, Error::<T>::AlreadyProcessed);
 		use MessageExecutionStatus::*;
-		let mut weight_counter = WeightMeter::from_limit(weight_limit);
+		let mut weight_counter = WeightMeter::with_limit(weight_limit);
 		match Self::process_message_payload(
 			origin.clone(),
 			page_index,
@@ -1150,7 +1150,7 @@ impl<T: Config> Pallet<T> {
 		//loop around this origin
 		let starting_origin = ServiceHead::<T>::get().unwrap();
 
-		while let Some(head) = Self::bump_service_head(&mut WeightMeter::max_limit()) {
+		while let Some(head) = Self::bump_service_head(&mut WeightMeter::new()) {
 			ensure!(
 				BookStateFor::<T>::contains_key(&head),
 				"Service head must point to an existing book"
@@ -1362,7 +1362,7 @@ impl<T: Config> ServiceQueues for Pallet<T> {
 	fn service_queues(weight_limit: Weight) -> Weight {
 		// The maximum weight that processing a single message may take.
 		let overweight_limit = weight_limit;
-		let mut weight = WeightMeter::from_limit(weight_limit);
+		let mut weight = WeightMeter::with_limit(weight_limit);
 
 		let mut next = match Self::bump_service_head(&mut weight) {
 			Some(h) => h,
@@ -1402,7 +1402,7 @@ impl<T: Config> ServiceQueues for Pallet<T> {
 		weight_limit: Weight,
 		(message_origin, page, index): Self::OverweightMessageAddress,
 	) -> Result<Weight, ExecuteOverweightError> {
-		let mut weight = WeightMeter::from_limit(weight_limit);
+		let mut weight = WeightMeter::with_limit(weight_limit);
 		if weight
 			.try_consume(
 				T::WeightInfo::execute_overweight_page_removed()

substrate/frame/message-queue/src/tests.rs

@@ -381,15 +381,15 @@ fn service_queue_bails() {
 	// Not enough weight for `service_queue_base`.
 	build_and_execute::<Test>(|| {
 		set_weight("service_queue_base", 2.into_weight());
-		let mut meter = WeightMeter::from_limit(1.into_weight());
+		let mut meter = WeightMeter::with_limit(1.into_weight());
 
 		assert_storage_noop!(MessageQueue::service_queue(0u32.into(), &mut meter, Weight::MAX));
 		assert!(meter.consumed().is_zero());
 	});
 	// Not enough weight for `ready_ring_unknit`.
 	build_and_execute::<Test>(|| {
 		set_weight("ready_ring_unknit", 2.into_weight());
-		let mut meter = WeightMeter::from_limit(1.into_weight());
+		let mut meter = WeightMeter::with_limit(1.into_weight());
 
 		assert_storage_noop!(MessageQueue::service_queue(0u32.into(), &mut meter, Weight::MAX));
 		assert!(meter.consumed().is_zero());
@@ -399,7 +399,7 @@ fn service_queue_bails() {
 		set_weight("service_queue_base", 2.into_weight());
 		set_weight("ready_ring_unknit", 2.into_weight());
 
-		let mut meter = WeightMeter::from_limit(3.into_weight());
+		let mut meter = WeightMeter::with_limit(3.into_weight());
 		assert_storage_noop!(MessageQueue::service_queue(0.into(), &mut meter, Weight::MAX));
 		assert!(meter.consumed().is_zero());
 	});
@@ -426,7 +426,7 @@ fn service_page_works() {
 			msgs -= process;
 
 			//  Enough weight to process `process` messages.
-			let mut meter = WeightMeter::from_limit(((2 + (3 + 1) * process) as u64).into_weight());
+			let mut meter = WeightMeter::with_limit(((2 + (3 + 1) * process) as u64).into_weight());
 			System::reset_events();
 			let (processed, status) =
 				crate::Pallet::<Test>::service_page(&Here, &mut book, &mut meter, Weight::MAX);
@@ -449,7 +449,7 @@ fn service_page_bails() {
 	// Not enough weight for `service_page_base_completion`.
 	build_and_execute::<Test>(|| {
 		set_weight("service_page_base_completion", 2.into_weight());
-		let mut meter = WeightMeter::from_limit(1.into_weight());
+		let mut meter = WeightMeter::with_limit(1.into_weight());
 
 		let (page, _) = full_page::<Test>();
 		let mut book = book_for::<Test>(&page);
@@ -466,7 +466,7 @@ fn service_page_bails() {
 	// Not enough weight for `service_page_base_no_completion`.
 	build_and_execute::<Test>(|| {
 		set_weight("service_page_base_no_completion", 2.into_weight());
-		let mut meter = WeightMeter::from_limit(1.into_weight());
+		let mut meter = WeightMeter::with_limit(1.into_weight());
 
 		let (page, _) = full_page::<Test>();
 		let mut book = book_for::<Test>(&page);
@@ -487,7 +487,7 @@ fn service_page_item_bails() {
 	build_and_execute::<Test>(|| {
 		let _guard = StorageNoopGuard::default();
 		let (mut page, _) = full_page::<Test>();
-		let mut weight = WeightMeter::from_limit(10.into_weight());
+		let mut weight = WeightMeter::with_limit(10.into_weight());
 		let overweight_limit = 10.into_weight();
 		set_weight("service_page_item", 11.into_weight());
 
@@ -518,7 +518,7 @@ fn service_page_suspension_works() {
 		Pages::<Test>::insert(Here, 0, page);
 
 		// First we process 5 messages from this page.
-		let mut meter = WeightMeter::from_limit(5.into_weight());
+		let mut meter = WeightMeter::with_limit(5.into_weight());
 		let (_, status) =
 			crate::Pallet::<Test>::service_page(&Here, &mut book, &mut meter, Weight::MAX);
 
@@ -534,7 +534,7 @@ fn service_page_suspension_works() {
 			let (_, status) = crate::Pallet::<Test>::service_page(
 				&Here,
 				&mut book,
-				&mut WeightMeter::max_limit(),
+				&mut WeightMeter::new(),
 				Weight::MAX,
 			);
 			assert_eq!(status, NoProgress);
@@ -546,7 +546,7 @@ fn service_page_suspension_works() {
 		let (_, status) = crate::Pallet::<Test>::service_page(
 			&Here,
 			&mut book,
-			&mut WeightMeter::max_limit(),
+			&mut WeightMeter::new(),
 			Weight::MAX,
 		);
 		assert_eq!(status, NoMore);
@@ -564,7 +564,7 @@ fn bump_service_head_works() {
 
 		// Bump 99 times.
 		for i in 0..99 {
-			let current = MessageQueue::bump_service_head(&mut WeightMeter::max_limit()).unwrap();
+			let current = MessageQueue::bump_service_head(&mut WeightMeter::new()).unwrap();
 			assert_eq!(current, [Here, There, Everywhere(0)][i % 3]);
 		}
 
@@ -581,7 +581,7 @@ fn bump_service_head_bails() {
 		setup_bump_service_head::<Test>(0.into(), 1.into());
 
 		let _guard = StorageNoopGuard::default();
-		let mut meter = WeightMeter::from_limit(1.into_weight());
+		let mut meter = WeightMeter::with_limit(1.into_weight());
 		assert!(MessageQueue::bump_service_head(&mut meter).is_none());
 		assert_eq!(meter.consumed(), 0.into_weight());
 	});
@@ -591,7 +591,7 @@ fn bump_service_head_bails() {
 fn bump_service_head_trivial_works() {
 	build_and_execute::<Test>(|| {
 		set_weight("bump_service_head", 2.into_weight());
-		let mut meter = WeightMeter::max_limit();
+		let mut meter = WeightMeter::new();
 
 		assert_eq!(MessageQueue::bump_service_head(&mut meter), None, "Cannot bump");
 		assert_eq!(meter.consumed(), 2.into_weight());
@@ -616,15 +616,15 @@ fn bump_service_head_no_head_noops() {
 		ServiceHead::<Test>::kill();
 
 		// Nothing happens.
-		assert_storage_noop!(MessageQueue::bump_service_head(&mut WeightMeter::max_limit()));
+		assert_storage_noop!(MessageQueue::bump_service_head(&mut WeightMeter::new()));
 	});
 }
 
 #[test]
 fn service_page_item_consumes_correct_weight() {
 	build_and_execute::<Test>(|| {
 		let mut page = page::<Test>(b"weight=3");
-		let mut weight = WeightMeter::from_limit(10.into_weight());
+		let mut weight = WeightMeter::with_limit(10.into_weight());
 		let overweight_limit = 0.into_weight();
 		set_weight("service_page_item", 2.into_weight());
 
@@ -648,7 +648,7 @@ fn service_page_item_consumes_correct_weight() {
 fn service_page_item_skips_perm_overweight_message() {
 	build_and_execute::<Test>(|| {
 		let mut page = page::<Test>(b"TooMuch");
-		let mut weight = WeightMeter::from_limit(2.into_weight());
+		let mut weight = WeightMeter::with_limit(2.into_weight());
 		let overweight_limit = 0.into_weight();
 		set_weight("service_page_item", 2.into_weight());
 

substrate/frame/scheduler/src/benchmarking.rs

@@ -131,7 +131,7 @@ benchmarks! {
 		let now = BlockNumberFor::<T>::from(BLOCK_NUMBER);
 		IncompleteSince::<T>::put(now - One::one());
 	}: {
-		Scheduler::<T>::service_agendas(&mut WeightMeter::max_limit(), now, 0);
+		Scheduler::<T>::service_agendas(&mut WeightMeter::new(), now, 0);
 	} verify {
 		assert_eq!(IncompleteSince::<T>::get(), Some(now - One::one()));
 	}
@@ -143,7 +143,7 @@ benchmarks! {
 		fill_schedule::<T>(now, s)?;
 		let mut executed = 0;
 	}: {
-		Scheduler::<T>::service_agenda(&mut WeightMeter::max_limit(), &mut executed, now, now, 0);
+		Scheduler::<T>::service_agenda(&mut WeightMeter::new(), &mut executed, now, now, 0);
 	} verify {
 		assert_eq!(executed, 0);
 	}
@@ -154,7 +154,7 @@ benchmarks! {
 		let now = BLOCK_NUMBER.into();
 		let task = make_task::<T>(false, false, false, None, 0);
 		// prevent any tasks from actually being executed as we only want the surrounding weight.
-		let mut counter = WeightMeter::from_limit(Weight::zero());
+		let mut counter = WeightMeter::with_limit(Weight::zero());
 	}: {
 		let result = Scheduler::<T>::service_task(&mut counter, now, now, 0, true, task);
 	} verify {
@@ -172,7 +172,7 @@ benchmarks! {
 		let now = BLOCK_NUMBER.into();
 		let task = make_task::<T>(false, false, false, Some(s), 0);
 		// prevent any tasks from actually being executed as we only want the surrounding weight.
-		let mut counter = WeightMeter::from_limit(Weight::zero());
+		let mut counter = WeightMeter::with_limit(Weight::zero());
 	}: {
 		let result = Scheduler::<T>::service_task(&mut counter, now, now, 0, true, task);
 	} verify {
@@ -184,7 +184,7 @@ benchmarks! {
 		let now = BLOCK_NUMBER.into();
 		let task = make_task::<T>(false, true, false, None, 0);
 		// prevent any tasks from actually being executed as we only want the surrounding weight.
-		let mut counter = WeightMeter::from_limit(Weight::zero());
+		let mut counter = WeightMeter::with_limit(Weight::zero());
 	}: {
 		let result = Scheduler::<T>::service_task(&mut counter, now, now, 0, true, task);
 	} verify {
@@ -196,15 +196,15 @@ benchmarks! {
 		let now = BLOCK_NUMBER.into();
 		let task = make_task::<T>(true, false, false, None, 0);
 		// prevent any tasks from actually being executed as we only want the surrounding weight.
-		let mut counter = WeightMeter::from_limit(Weight::zero());
+		let mut counter = WeightMeter::with_limit(Weight::zero());
 	}: {
 		let result = Scheduler::<T>::service_task(&mut counter, now, now, 0, true, task);
 	} verify {
 	}
 
 	// `execute_dispatch` when the origin is `Signed`, not counting the dispatable's weight.
 	execute_dispatch_signed {
-		let mut counter = WeightMeter::max_limit();
+		let mut counter = WeightMeter::new();
 		let origin = make_origin::<T>(true);
 		let call = T::Preimages::realize(&make_call::<T>(None)).unwrap().0;
 	}: {
@@ -215,7 +215,7 @@ benchmarks! {
 
 	// `execute_dispatch` when the origin is not `Signed`, not counting the dispatable's weight.
 	execute_dispatch_unsigned {
-		let mut counter = WeightMeter::max_limit();
+		let mut counter = WeightMeter::new();
 		let origin = make_origin::<T>(false);
 		let call = T::Preimages::realize(&make_call::<T>(None)).unwrap().0;
 	}: {

substrate/frame/scheduler/src/lib.rs

@@ -320,7 +320,7 @@ pub mod pallet {
 	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
 		/// Execute the scheduled calls
 		fn on_initialize(now: BlockNumberFor<T>) -> Weight {
-			let mut weight_counter = WeightMeter::from_limit(T::MaximumWeight::get());
+			let mut weight_counter = WeightMeter::with_limit(T::MaximumWeight::get());
 			Self::service_agendas(&mut weight_counter, now, u32::max_value());
 			weight_counter.consumed()
 		}