Basic weights builder.

bin/node-template/runtime/src/lib.rs

@@ -137,6 +137,7 @@ parameter_types! {
 impl system::Trait for Runtime {
 	/// The basic call filter to use in dispatchable.
 	type BaseCallFilter = ();
+	type Weights = ();
 	/// The identifier used to distinguish between accounts.
 	type AccountId = AccountId;
 	/// The aggregated dispatch type that is available for extrinsics.

bin/node/runtime/src/lib.rs

@@ -28,11 +28,11 @@ use frame_support::{
 	construct_runtime, parameter_types, debug, RuntimeDebug,
 	weights::{
 		Weight, IdentityFee,
-		constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND},
+		constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND}, DispatchClass,
 	},
 	traits::{Currency, Imbalance, KeyOwnerProofSystem, OnUnbalanced, Randomness, LockIdentifier},
 };
-use frame_system::{EnsureRoot, EnsureOneOf};
+use frame_system::{EnsureRoot, EnsureOneOf, Weights, ExtrinsicDispatchClass};
 use frame_support::traits::InstanceFilter;
 use codec::{Encode, Decode};
 use sp_core::{
@@ -142,12 +142,25 @@ parameter_types! {
 		* MaximumBlockWeight::get();
 	pub const MaximumBlockLength: u32 = 5 * 1024 * 1024;
 	pub const Version: RuntimeVersion = VERSION;
+
+	pub RuntimeWeights: Weights = Weights::builder()
+		.base_block(BlockExecutionWeight::get())
+		.base_extrinsic(ExtrinsicBaseWeight::get(), ExtrinsicDispatchClass::All)
+		.max_total(AvailableBlockRatio::get() * MaximumBlockWeight::get(), DispatchClass::Normal)
+		.max_total(MaximumBlockWeight::get(), DispatchClass::Operational)
+		.reserved(
+			Perbill::one().saturating_sub(AvailableBlockRatio::get()) * MaximumBlockWeight::get(),
+			DispatchClass::Operational
+		)
+		.avg_block_initialization(AVERAGE_ON_INITIALIZE_WEIGHT)
+		.build();
 }
 
 const_assert!(AvailableBlockRatio::get().deconstruct() >= AVERAGE_ON_INITIALIZE_WEIGHT.deconstruct());
 
 impl frame_system::Trait for Runtime {
 	type BaseCallFilter = ();
+	type Weights = RuntimeWeights;
 	type Origin = Origin;
 	type Call = Call;
 	type Index = Index;
@@ -1115,4 +1128,9 @@ mod tests {
 
 		is_submit_signed_transaction::<Runtime>();
 	}
+
+	#[test]
+	fn weights_are_valid() {
+		RuntimeWeights::get().validate()
+	}
 }

frame/balances/src/lib.rs

@@ -849,6 +849,7 @@ impl<T: Subtrait<I>, I: Instance> PartialEq for ElevatedTrait<T, I> {
 impl<T: Subtrait<I>, I: Instance> Eq for ElevatedTrait<T, I> {}
 impl<T: Subtrait<I>, I: Instance> frame_system::Trait for ElevatedTrait<T, I> {
 	type BaseCallFilter = T::BaseCallFilter;
+	type Weights = T::Weights;
 	type Origin = T::Origin;
 	type Call = T::Call;
 	type Index = T::Index;

frame/generic-asset/src/lib.rs

@@ -1121,6 +1121,7 @@ impl<T: Subtrait> PartialEq for ElevatedTrait<T> {
 impl<T: Subtrait> Eq for ElevatedTrait<T> {}
 impl<T: Subtrait> frame_system::Trait for ElevatedTrait<T> {
 	type BaseCallFilter = T::BaseCallFilter;
+	type Weights = T::Weights;
 	type Origin = T::Origin;
 	type Call = T::Call;
 	type Index = T::Index;

frame/staking/fuzzer/src/mock.rs

@@ -58,6 +58,7 @@ pub struct Test;
 
 impl frame_system::Trait for Test {
 	type BaseCallFilter = ();
+	type Weights = ();
 	type Origin = Origin;
 	type DbWeight = ();
 	type BlockExecutionWeight = ();

frame/support/src/weights.rs

@@ -589,7 +589,7 @@ pub trait WeightToFeePolynomial {
 		Self::polynomial().iter().fold(Self::Balance::saturated_from(0u32), |mut acc, args| {
 			let w = Self::Balance::saturated_from(*weight).saturating_pow(args.degree.into());
 
-			// The sum could get negative. Therefore we only sum with the accumulator. 
+			// The sum could get negative. Therefore we only sum with the accumulator.
 			// The Perbill Mul implementation is non overflowing.
 			let frac = args.coeff_frac * w;
 			let integer = args.coeff_integer.saturating_mul(w);

frame/system/src/lib.rs

@@ -148,11 +148,227 @@ pub fn extrinsics_data_root<H: Hash>(xts: Vec<Vec<u8>>) -> H::Output {
 	H::ordered_trie_root(xts)
 }
 
+/// A struct holding value for each `DispatchClass`.
+#[derive(RuntimeDebug, Default, Clone)]
+pub struct ForDispatchClass<T> {
+	/// Value for `Normal` extrinsics.
+	pub normal: T,
+	/// Value for `Operational` extrinsics.
+	pub operational: T,
+	/// Value for `Mandatory` extrinsics.
+	pub mandatory: T,
+}
+
+impl<T: Copy> ForDispatchClass<T> {
+	/// Set the same value for all classes.
+	pub fn set(&mut self, value: T, class: ExtrinsicDispatchClass) {
+		match class {
+			ExtrinsicDispatchClass::All => {
+				self.normal = value;
+				self.operational = value;
+				self.mandatory = value;
+			},
+			ExtrinsicDispatchClass::One(DispatchClass::Normal) => {
+				self.normal = value;
+			},
+			ExtrinsicDispatchClass::One(DispatchClass::Operational) => {
+				self.operational = value;
+			},
+			ExtrinsicDispatchClass::One(DispatchClass::Mandatory) => {
+				self.mandatory = value;
+			},
+		}
+	}
+}
+
+struct Verified;
+struct Unverified;
+
+/// Weights configuration.
+#[derive(RuntimeDebug, Clone)]
+pub struct Weights {
+	/// Base weight of block execution.
+	pub base_block: Weight,
+	/// Base weight of single extrinsic of given class.
+	pub base_extrinsic: ForDispatchClass<Weight>,
+	/// Maximal weight of single extrinsic of given class.
+	///
+	/// `None` indicates that this class of extrinsics doesn't have a limit.
+	pub max_extrinsic: ForDispatchClass<Option<Weight>>,
+	/// Block reserved allowance for all extrinsics of a particular class.
+	///
+	/// Setting to `None` indicates that extrinsics of that class are allowed
+	/// to go over total block weight (but at most `max_allowance`).
+	/// Setting to `Some(x)` guarantees that at least `x` weight of particular class
+	/// is processed in every block.
+	pub reserved: ForDispatchClass<Option<Weight>>,
+	/// Block maximal total weight for all extrinsics of a particular class.
+	///
+	/// `None` indicates that weight sum of this class of extrinsics is not
+	/// restricted. Use this value carefuly, since it might produce heavily oversized
+	/// blocks.
+	///
+	/// In the worst case, the total weight consumed by a block is going to be:
+	/// `MAX(max_total) + MAX(reserved)`.
+	pub max_total: ForDispatchClass<Option<Weight>>,
+}
+
+impl Weights {
+	/// Verifies correctness of this `Weights` object.
+	pub fn validate(&self) {
+		fn or_max(w: Option<Weight>) -> Weight {
+			w.unwrap_or_else(|| Weight::max_value())
+		}
+		// Base cost must not be greater than max cost.
+		assert!(self.base_extrinsic.normal < or_max(self.max_extrinsic.normal));
+		assert!(self.base_extrinsic.operational < or_max(self.max_extrinsic.operational));
+		assert!(self.base_extrinsic.mandatory < or_max(self.max_extrinsic.mandatory));
+		// Max extrinsic can't be greater than max_total.
+		assert!(or_max(self.max_extrinsic.normal) <= or_max(self.max_total.normal));
+		assert!(or_max(self.max_extrinsic.operational) <= or_max(self.max_total.operational));
+		assert!(or_max(self.max_extrinsic.mandatory) <= or_max(self.max_total.mandatory));
+		// Make sure that if reserved is set it's greater than base_extrinsic.
+		assert!(
+			or_max(self.reserved.normal) > self.base_extrinsic.normal
+			|| or_max(self.reserved.normal) == 0
+		);
+		assert!(
+			or_max(self.reserved.operational) > self.base_extrinsic.operational
+			|| or_max(self.reserved.operational) == 0
+		);
+		assert!(
+			or_max(self.reserved.mandatory) > self.base_extrinsic.mandatory
+			|| or_max(self.reserved.mandatory) == 0
+		);
+		// Make sure that if total is set it's greater than base_block && base_extrinsic
+		assert!((
+				or_max(self.max_total.normal) > self.base_block
+				&& or_max(self.max_total.normal) > self.base_extrinsic.normal
+		) || or_max(self.max_total.normal) == 0);
+		assert!((
+			or_max(self.max_total.operational) > self.base_block
+			&& or_max(self.max_total.operational) > self.base_extrinsic.operational
+		) || or_max(self.max_total.operational) == 0);
+		assert!((
+			or_max(self.max_total.mandatory) > self.base_block
+			&& or_max(self.max_total.mandatory) > self.base_extrinsic.mandatory
+		) || or_max(self.max_total.mandatory) == 0);
+
+	}
+
+	/// Start constructing new `Weights` object.
+	///
+	/// By default all kinds except of `Mandatory` extrinsics are disallowed.
+	pub fn builder() -> WeightsBuilder {
+		let max_total = ForDispatchClass {
+			normal: Some(0),
+			operational: Some(0),
+			mandatory: None,
+		};
+		WeightsBuilder {
+			weights: Weights {
+				base_block: 0,
+				base_extrinsic: Default::default(),
+				max_extrinsic: max_total.clone(),
+				reserved: max_total.clone(),
+				max_total,
+			},
+			init_cost: Perbill::zero(),
+		}
+	}
+}
+
+/// Dispatch class to apply change to.
+pub enum ExtrinsicDispatchClass {
+	/// All dispatch classes.
+	All,
+	/// Single dispatch class.
+	One(DispatchClass),
+}
+
+impl From<DispatchClass> for ExtrinsicDispatchClass {
+	fn from(c: DispatchClass) -> Self {
+		ExtrinsicDispatchClass::One(c)
+	}
+}
+
+pub struct WeightsBuilder {
+	weights: Weights,
+	init_cost: Perbill,
+}
+
+impl WeightsBuilder {
+	/// Set base block weight.
+	pub fn base_block(mut self, base_block: Weight) -> Self {
+		self.weights.base_block = base_block;
+		self
+	}
+
+	/// Set base extrinsic weight for given dispatch class.
+	pub fn base_extrinsic(
+		mut self,
+		weight: Weight,
+		class: impl Into<ExtrinsicDispatchClass>,
+	) -> Self {
+		self.weights.base_extrinsic.set(weight, class.into());
+		self
+	}
+
+	/// Set maximal block total weight for given dispatch class.
+	pub fn max_total(
+		mut self,
+		max_allowance: Weight,
+		class: impl Into<ExtrinsicDispatchClass>,
+	) -> Self {
+		self.weights.max_total.set(max_allowance.into(), class.into());
+ 		self
+	}
+
+	/// Set reserved allowance for given dispatch class.
+	pub fn reserved(
+		mut self,
+		reserved: Weight,
+		class: impl Into<ExtrinsicDispatchClass>,
+	) -> Self {
+		self.weights.reserved.set(reserved.into(), class.into());
+		self
+	}
+
+	/// Average block initialization weight cost.
+	///
+	/// This value is used to derive maximal allowed extrinsic weight for each
+	/// class, based on the allowance.
+	pub fn avg_block_initialization(mut self, init_cost: Perbill) -> Self {
+		self.init_cost = init_cost;
+		self
+	}
+
+	/// Construct the `Weights` object.
+	pub fn build(self) -> Weights {
+		use sp_runtime::traits::Saturating;
+		// compute max extrinsic size
+		let Self { mut weights, init_cost } = self;
+
+		// compute max weight of single extrinsic
+		let max_rate = Perbill::one().saturating_sub(init_cost);
+		weights.max_extrinsic.normal = weights.max_total.normal.map(|x| max_rate * x);
+		weights.max_extrinsic.operational = weights.max_total.operational.map(|x| max_rate * x);
+		weights.max_extrinsic.mandatory = weights.max_total.mandatory.map(|x| max_rate * x);
+
+		weights.validate();
+
+		weights
+	}
+}
+
 pub trait Trait: 'static + Eq + Clone {
 	/// The basic call filter to use in Origin. All origins are built with this filter as base,
 	/// except Root.
 	type BaseCallFilter: Filter<Self::Call>;
 
+	/// Block, Extrinsics & DB weights configuration.
+	type Weights: Get<Weights>;
+
 	/// The `Origin` type used by dispatchable calls.
 	type Origin:
 		Into<Result<RawOrigin<Self::AccountId>, Self::Origin>>