Introduce sensible weight constants (#12868)

* Introduce sensible weight constants

* cargo fmt

* Remove unused import

* Add missing import

* ".git/.scripts/bench-bot.sh" pallet dev pallet_lottery

Co-authored-by: command-bot <>

substrate/utils/frame/benchmarking-cli/src/block/bench.rs

@@ -18,7 +18,7 @@
 //! Contains the core benchmarking logic.
 
 use codec::DecodeAll;
-use frame_support::weights::constants::WEIGHT_PER_NANOS;
+use frame_support::weights::constants::WEIGHT_REF_TIME_PER_NANOS;
 use frame_system::ConsumedWeight;
 use sc_block_builder::{BlockBuilderApi, BlockBuilderProvider};
 use sc_cli::{Error, Result};
@@ -148,7 +148,7 @@ where
 
 		let weight = ConsumedWeight::decode_all(&mut raw_weight)?;
 		// Should be divisible, but still use floats in case we ever change that.
-		Ok((weight.total().ref_time() as f64 / WEIGHT_PER_NANOS.ref_time() as f64).floor()
+		Ok((weight.total().ref_time() as f64 / WEIGHT_REF_TIME_PER_NANOS as f64).floor()
 			as NanoSeconds)
 	}
 

substrate/utils/frame/benchmarking-cli/src/overhead/README.md

@@ -30,7 +30,8 @@ The file will contain the concrete weight value and various statistics about the
 ///   99th: 3_631_863
 ///   95th: 3_595_674
 ///   75th: 3_526_435
-pub const BlockExecutionWeight: Weight = WEIGHT_PER_NANOS.saturating_mul(3_532_484);
+pub const BlockExecutionWeight: Weight =
+    Weight::from_ref_time(WEIGHT_REF_TIME_PER_NANOS.saturating_mul(3_532_484));
 ```
 
 In this example it takes 3.5 ms to execute an empty block. That means that it always takes at least 3.5 ms to execute *any* block.
@@ -59,7 +60,8 @@ The relevant section in the output file looks like this:
 ///   99th: 68_758
 ///   95th: 67_843
 ///   75th: 67_749
-pub const ExtrinsicBaseWeight: Weight = WEIGHT_PER_NANOS.saturating_mul(67_745);
+pub const ExtrinsicBaseWeight: Weight =
+    Weight::from_ref_time(WEIGHT_REF_TIME_PER_NANOS.saturating_mul(67_745));
 ```
 
 In this example it takes 67.7 µs to execute a NO-OP extrinsic. That means that it always takes at least 67.7 µs to execute *any* extrinsic.

substrate/utils/frame/benchmarking-cli/src/overhead/weights.hbs

@@ -14,7 +14,7 @@
 {{/each}}
 
 use sp_core::parameter_types;
-use sp_weights::{constants::WEIGHT_PER_NANOS, Weight};
+use sp_weights::{constants::WEIGHT_REF_TIME_PER_NANOS, Weight};
 
 parameter_types! {
 	{{#if (eq short_name "block")}}
@@ -34,7 +34,8 @@ parameter_types! {
 	///   99th: {{underscore stats.p99}}
 	///   95th: {{underscore stats.p95}}
 	///   75th: {{underscore stats.p75}}
-	pub const {{long_name}}Weight: Weight = WEIGHT_PER_NANOS.saturating_mul({{underscore weight}});
+	pub const {{long_name}}Weight: Weight =
+		Weight::from_ref_time(WEIGHT_REF_TIME_PER_NANOS.saturating_mul({{underscore weight}}));
 }
 
 #[cfg(test)]
@@ -51,23 +52,23 @@ mod test_weights {
 		{{#if (eq short_name "block")}}
 		// At least 100 µs.
 		assert!(
-			w.ref_time() >= 100u64 * constants::WEIGHT_PER_MICROS.ref_time(),
+			w.ref_time() >= 100u64 * constants::WEIGHT_REF_TIME_PER_MICROS,
 			"Weight should be at least 100 µs."
 		);
 		// At most 50 ms.
 		assert!(
-			w.ref_time() <= 50u64 * constants::WEIGHT_PER_MILLIS.ref_time(),
+			w.ref_time() <= 50u64 * constants::WEIGHT_REF_TIME_PER_MILLIS,
 			"Weight should be at most 50 ms."
 		);
 		{{else}}
 		// At least 10 µs.
 		assert!(
-			w.ref_time() >= 10u64 * constants::WEIGHT_PER_MICROS.ref_time(),
+			w.ref_time() >= 10u64 * constants::WEIGHT_REF_TIME_PER_MICROS,
 			"Weight should be at least 10 µs."
 		);
 		// At most 1 ms.
 		assert!(
-			w.ref_time() <= constants::WEIGHT_PER_MILLIS.ref_time(),
+			w.ref_time() <= constants::WEIGHT_REF_TIME_PER_MILLIS,
 			"Weight should be at most 1 ms."
 		);
 		{{/if}}

substrate/utils/frame/benchmarking-cli/src/storage/README.md

@@ -69,7 +69,7 @@ The interesting part in the generated weight file tells us the weight constants
 ///   99th: 18_270
 ///   95th: 16_190
 ///   75th: 14_819
-read: 14_262 * constants::WEIGHT_PER_NANOS,
+read: 14_262 * constants::WEIGHT_REF_TIME_PER_NANOS,
 
 /// Time to write one storage item.
 /// Calculated by multiplying the *Average* of all values with `1.1` and adding `0`.
@@ -84,7 +84,7 @@ read: 14_262 * constants::WEIGHT_PER_NANOS,
 ///   99th: 135_839
 ///   95th: 106_129
 ///   75th: 79_239
-write: 71_347 * constants::WEIGHT_PER_NANOS,
+write: 71_347 * constants::WEIGHT_REF_TIME_PER_NANOS,
 ```
 
 ## Arguments

substrate/utils/frame/benchmarking-cli/src/storage/weights.hbs

@@ -43,7 +43,7 @@ pub mod constants {
 			///   99th: {{underscore read.0.p99}}
 			///   95th: {{underscore read.0.p95}}
 			///   75th: {{underscore read.0.p75}}
-			read: {{underscore read_weight}} * constants::WEIGHT_PER_NANOS,
+			read: {{underscore read_weight}} * constants::WEIGHT_REF_TIME_PER_NANOS,
 
 			/// Time to write one storage item.
 			/// Calculated by multiplying the *{{params.weight_params.weight_metric}}* of all values with `{{params.weight_params.weight_mul}}` and adding `{{params.weight_params.weight_add}}`.
@@ -58,7 +58,7 @@ pub mod constants {
 			///   99th: {{underscore write.0.p99}}
 			///   95th: {{underscore write.0.p95}}
 			///   75th: {{underscore write.0.p75}}
-			write: {{underscore write_weight}} * constants::WEIGHT_PER_NANOS,
+			write: {{underscore write_weight}} * constants::WEIGHT_REF_TIME_PER_NANOS,
 		};
 	}
 
@@ -74,20 +74,20 @@ pub mod constants {
 		fn bound() {
 			// At least 1 µs.
 			assert!(
-				W::get().reads(1).ref_time() >= constants::WEIGHT_PER_MICROS.ref_time(),
+				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_PER_MICROS.ref_time(),
+				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_PER_MILLIS.ref_time(),
+				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_PER_MILLIS.ref_time(),
+				W::get().writes(1).ref_time() <= constants::WEIGHT_REF_TIME_PER_MILLIS,
 				"Write weight should be at most 1 ms."
 			);
 		}