Weight V2 (Chromatic Weight)

.maintain/frame-weight-template.hbs

@@ -30,7 +30,7 @@
 #![allow(unused_parens)]
 #![allow(unused_imports)]
 
-use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use frame_support::{traits::Get, weights::{ComputationWeight as Weight, constants::RocksDbWeight}};
 use sp_std::marker::PhantomData;
 
 /// Weight functions needed for {{pallet}}.

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

@@ -138,7 +138,10 @@ parameter_types! {
 	pub const Version: RuntimeVersion = VERSION;
 	/// We allow for 2 seconds of compute with a 6 second average block time.
 	pub BlockWeights: frame_system::limits::BlockWeights = frame_system::limits::BlockWeights
-		::with_sensible_defaults(2 * WEIGHT_PER_SECOND, NORMAL_DISPATCH_RATIO);
+		::with_sensible_defaults(Weight::new()
+			.set_computation(2 * WEIGHT_PER_SECOND)
+			.set_bandwidth(5 * 1024 * 1024), // 5 MB
+		NORMAL_DISPATCH_RATIO);
 	pub BlockLength: frame_system::limits::BlockLength = frame_system::limits::BlockLength
 		::max_with_normal_ratio(5 * 1024 * 1024, NORMAL_DISPATCH_RATIO);
 	pub const SS58Prefix: u8 = 42;

bin/node/executor/tests/basic.rs

@@ -18,7 +18,7 @@
 use codec::{Decode, Encode, Joiner};
 use frame_support::{
 	traits::Currency,
-	weights::{DispatchClass, DispatchInfo, GetDispatchInfo},
+	weights::{DispatchClass, DispatchInfo, GetDispatchInfo, Weight},
 };
 use frame_system::{self, AccountInfo, EventRecord, Phase};
 use sp_core::{storage::well_known_keys, traits::Externalities, NeverNativeValue};
@@ -700,7 +700,7 @@ fn deploying_wasm_contract_should_work() {
 				function: Call::Contracts(
 					pallet_contracts::Call::instantiate_with_code::<Runtime> {
 						value: 0,
-						gas_limit: 500_000_000,
+						gas_limit: Weight::from_computation(500_000_000),
 						storage_deposit_limit: None,
 						code: transfer_code,
 						data: Vec::new(),
@@ -713,7 +713,7 @@ fn deploying_wasm_contract_should_work() {
 				function: Call::Contracts(pallet_contracts::Call::call::<Runtime> {
 					dest: sp_runtime::MultiAddress::Id(addr.clone()),
 					value: 10,
-					gas_limit: 500_000_000,
+					gas_limit: Weight::from_computation(500_000_000),
 					storage_deposit_limit: None,
 					data: vec![0x00, 0x01, 0x02, 0x03],
 				}),

bin/node/executor/tests/fees.rs

@@ -197,18 +197,18 @@ fn transaction_fee_is_correct() {
 		let mut balance_alice = (100 - 69) * DOLLARS;
 
 		let base_weight = ExtrinsicBaseWeight::get();
-		let base_fee = IdentityFee::<Balance>::calc(&base_weight);
+		let base_fee = IdentityFee::<Balance>::calc(&base_weight.computation());
 
 		let length_fee = TransactionByteFee::get() * (xt.clone().encode().len() as Balance);
 		balance_alice -= length_fee;
 
 		let weight = default_transfer_call().get_dispatch_info().weight;
-		let weight_fee = IdentityFee::<Balance>::calc(&weight);
+		let weight_fee = IdentityFee::<Balance>::calc(&weight.computation());
 
 		// we know that weight to fee multiplier is effect-less in block 1.
 		// current weight of transfer = 200_000_000
 		// Linear weight to fee is 1:1 right now (1 weight = 1 unit of balance)
-		assert_eq!(weight_fee, weight as Balance);
+		assert_eq!(weight_fee, weight.computation() as Balance);
 		balance_alice -= base_fee;
 		balance_alice -= weight_fee;
 		balance_alice -= tip;

bin/node/runtime/src/impls.rs

@@ -73,7 +73,9 @@ mod multiplier_tests {
 	}
 
 	fn target() -> Weight {
-		TargetBlockFullness::get() * max_normal()
+		Weight::new()
+			.set_computation(TargetBlockFullness::get() * max_normal().computation())
+			.set_bandwidth(TargetBlockFullness::get() * max_normal().bandwidth())
 	}
 
 	// update based on runtime impl.
@@ -94,13 +96,13 @@ mod multiplier_tests {
 		let previous_float = previous_float.max(min_multiplier().into_inner() as f64 / accuracy);
 
 		// maximum tx weight
-		let m = max_normal() as f64;
+		let m = max_normal().computation() as f64;
 		// block weight always truncated to max weight
-		let block_weight = (block_weight as f64).min(m);
+		let block_weight = (block_weight.computation() as f64).min(m);
 		let v: f64 = AdjustmentVariable::get().to_float();
 
 		// Ideal saturation in terms of weight
-		let ss = target() as f64;
+		let ss = target().computation() as f64;
 		// Current saturation in terms of weight
 		let s = block_weight;
 
@@ -119,7 +121,7 @@ mod multiplier_tests {
 			.unwrap()
 			.into();
 		t.execute_with(|| {
-			System::set_block_consumed_resources(w, 0);
+			System::set_block_consumed_resources(Some(w.computation()), Some(w.bandwidth()), None);
 			assertions()
 		});
 	}
@@ -128,9 +130,9 @@ mod multiplier_tests {
 	fn truth_value_update_poc_works() {
 		let fm = Multiplier::saturating_from_rational(1, 2);
 		let test_set = vec![
-			(0, fm.clone()),
-			(100, fm.clone()),
-			(1000, fm.clone()),
+			(Weight::zero(), fm.clone()),
+			(Weight::from_computation(100), fm.clone()),
+			(Weight::from_computation(1000), fm.clone()),
 			(target(), fm.clone()),
 			(max_normal() / 2, fm.clone()),
 			(max_normal(), fm.clone()),
@@ -160,7 +162,7 @@ mod multiplier_tests {
 	#[test]
 	fn multiplier_cannot_go_below_limit() {
 		// will not go any further below even if block is empty.
-		run_with_system_weight(0, || {
+		run_with_system_weight(Weight::zero(), || {
 			let next = runtime_multiplier_update(min_multiplier());
 			assert_eq!(next, min_multiplier());
 		})
@@ -178,7 +180,7 @@ mod multiplier_tests {
 		// 1 < 0.00001 * k * 0.1875
 		// 10^9 / 1875 < k
 		// k > 533_333 ~ 18,5 days.
-		run_with_system_weight(0, || {
+		run_with_system_weight(Weight::zero(), || {
 			// start from 1, the default.
 			let mut fm = Multiplier::one();
 			let mut iterations: u64 = 0;
@@ -214,7 +216,8 @@ mod multiplier_tests {
 		// `cargo test congested_chain_simulation -- --nocapture` to get some insight.
 
 		// almost full. The entire quota of normal transactions is taken.
-		let block_weight = BlockWeights::get().get(DispatchClass::Normal).max_total.unwrap() - 100;
+		let block_weight = BlockWeights::get().get(DispatchClass::Normal).max_total.unwrap() -
+			Weight::from_computation(100);
 
 		// Default substrate weight.
 		let tx_weight = frame_support::weights::constants::ExtrinsicBaseWeight::get();
@@ -233,8 +236,9 @@ mod multiplier_tests {
 				}
 				fm = next;
 				iterations += 1;
-				let fee =
-					<Runtime as pallet_transaction_payment::Config>::WeightToFee::calc(&tx_weight);
+				let fee = <Runtime as pallet_transaction_payment::Config>::WeightToFee::calc(
+					&tx_weight.computation(),
+				);
 				let adjusted_fee = fm.saturating_mul_acc_int(fee);
 				println!(
 					"iteration {}, new fm = {:?}. Fee at this point is: {} units / {} millicents, \
@@ -336,27 +340,27 @@ mod multiplier_tests {
 
 	#[test]
 	fn weight_to_fee_should_not_overflow_on_large_weights() {
-		let kb = 1024 as Weight;
+		let kb = 1024 as u64;
 		let mb = kb * kb;
 		let max_fm = Multiplier::saturating_from_integer(i128::MAX);
 
 		// check that for all values it can compute, correctly.
 		vec![
-			0,
-			1,
-			10,
-			1000,
-			kb,
-			10 * kb,
-			100 * kb,
-			mb,
-			10 * mb,
-			2147483647,
-			4294967295,
+			Weight::zero(),
+			Weight::one(),
+			Weight::from_computation(10),
+			Weight::from_computation(1000),
+			Weight::from_computation(kb),
+			Weight::from_computation(10 * kb),
+			Weight::from_computation(100 * kb),
+			Weight::from_computation(mb),
+			Weight::from_computation(10 * mb),
+			Weight::from_computation(2147483647),
+			Weight::from_computation(4294967295),
 			BlockWeights::get().max_block / 2,
 			BlockWeights::get().max_block,
-			Weight::max_value() / 2,
-			Weight::max_value(),
+			Weight::MAX / 2,
+			Weight::MAX,
 		]
 		.into_iter()
 		.for_each(|i| {
@@ -369,7 +373,7 @@ mod multiplier_tests {
 
 		// Some values that are all above the target and will cause an increase.
 		let t = target();
-		vec![t + 100, t * 2, t * 4].into_iter().for_each(|i| {
+		vec![t + Weight::from_computation(100), t * 2, t * 4].into_iter().for_each(|i| {
 			run_with_system_weight(i, || {
 				let fm = runtime_multiplier_update(max_fm);
 				// won't grow. The convert saturates everything.

bin/node/runtime/src/lib.rs

@@ -66,7 +66,7 @@ use sp_runtime::{
 	generic, impl_opaque_keys,
 	traits::{
 		self, BlakeTwo256, Block as BlockT, ConvertInto, NumberFor, OpaqueKeys,
-		SaturatedConversion, StaticLookup,
+		SaturatedConversion, Saturating, StaticLookup,
 	},
 	transaction_validity::{TransactionPriority, TransactionSource, TransactionValidity},
 	ApplyExtrinsicResult, FixedPointNumber, Perbill, Percent, Permill, Perquintill,
@@ -169,7 +169,9 @@ const AVERAGE_ON_INITIALIZE_RATIO: Perbill = Perbill::from_percent(10);
 /// by  Operational  extrinsics.
 const NORMAL_DISPATCH_RATIO: Perbill = Perbill::from_percent(75);
 /// We allow for 2 seconds of compute with a 6 second average block time.
-const MAXIMUM_BLOCK_WEIGHT: Weight = 2 * WEIGHT_PER_SECOND;
+const MAXIMUM_BLOCK_WEIGHT: Weight = Weight::new()
+	.set_computation(2 * WEIGHT_PER_SECOND)
+	.set_bandwidth(5 * 1024 * 1024); // 5 MB
 
 parameter_types! {
 	pub const BlockHashCount: BlockNumber = 2400;
@@ -673,11 +675,11 @@ impl pallet_election_provider_multi_phase::MinerConfig for Runtime {
 	// The unsigned submissions have to respect the weight of the submit_unsigned call, thus their
 	// weight estimate function is wired to this call's weight.
 	fn solution_weight(v: u32, t: u32, a: u32, d: u32) -> Weight {
-		<
+		Weight::from_computation(<
 			<Self as pallet_election_provider_multi_phase::Config>::WeightInfo
 			as
 			pallet_election_provider_multi_phase::WeightInfo
-		>::submit_unsigned(v, t, a, d)
+		>::submit_unsigned(v, t, a, d))
 	}
 }
 
@@ -1090,7 +1092,7 @@ parameter_types! {
 	pub DeletionQueueDepth: u32 = ((DeletionWeightLimit::get() / (
 			<Runtime as pallet_contracts::Config>::WeightInfo::on_initialize_per_queue_item(1) -
 			<Runtime as pallet_contracts::Config>::WeightInfo::on_initialize_per_queue_item(0)
-		)) / 5) as u32;
+		)).computation() / 5) as u32;
 	pub Schedule: pallet_contracts::Schedule<Runtime> = Default::default();
 }
 
@@ -1807,6 +1809,7 @@ impl_runtime_apis! {
 			storage_deposit_limit: Option<Balance>,
 			input_data: Vec<u8>,
 		) -> pallet_contracts_primitives::ContractExecResult<Balance> {
+			let gas_limit = Weight::from_computation(gas_limit);
 			Contracts::bare_call(origin, dest, value, gas_limit, storage_deposit_limit, input_data, true)
 		}
 
@@ -1820,6 +1823,7 @@ impl_runtime_apis! {
 			salt: Vec<u8>,
 		) -> pallet_contracts_primitives::ContractInstantiateResult<AccountId, Balance>
 		{
+			let gas_limit = Weight::from_computation(gas_limit);
 			Contracts::bare_instantiate(origin, value, gas_limit, storage_deposit_limit, code, data, salt, true)
 		}
 

frame/assets/src/weights.rs

@@ -39,7 +39,7 @@
 #![allow(unused_parens)]
 #![allow(unused_imports)]
 
-use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use frame_support::{traits::Get, weights::{ComputationWeight as Weight, constants::RocksDbWeight}};
 use sp_std::marker::PhantomData;
 
 /// Weight functions needed for pallet_assets.

frame/atomic-swap/src/lib.rs

@@ -146,7 +146,7 @@ where
 	}
 
 	fn weight(&self) -> Weight {
-		T::DbWeight::get().reads_writes(1, 1)
+		Weight::from_computation(T::DbWeight::get().reads_writes(1, 1))
 	}
 
 	fn cancel(&self, source: &AccountId) {
@@ -281,12 +281,12 @@ pub mod pallet {
 		/// - `proof`: Revealed proof of the claim.
 		/// - `action`: Action defined in the swap, it must match the entry in blockchain. Otherwise
 		///   the operation fails. This is used for weight calculation.
-		#[pallet::weight(
-			T::DbWeight::get().reads_writes(1, 1)
+		#[pallet::weight({
+			let computation_weight = T::DbWeight::get().reads_writes(1, 1)
 				.saturating_add(40_000_000)
-				.saturating_add((proof.len() as Weight).saturating_mul(100))
-				.saturating_add(action.weight())
-		)]
+				.saturating_add((proof.len() as u64).saturating_mul(100));
+			Weight::from_computation(computation_weight).saturating_add(action.weight())
+		})]
 		pub fn claim_swap(
 			origin: OriginFor<T>,
 			proof: Vec<u8>,

frame/atomic-swap/src/tests.rs

@@ -30,7 +30,10 @@ frame_support::construct_runtime!(
 
 parameter_types! {
 	pub BlockWeights: frame_system::limits::BlockWeights =
-		frame_system::limits::BlockWeights::simple_max(1024);
+		frame_system::limits::BlockWeights::simple_max(frame_support::weights::Weight::new()
+			.set_computation(1024)
+			.set_bandwidth(1024)
+		);
 }
 impl frame_system::Config for Test {
 	type BaseCallFilter = frame_support::traits::Everything;

frame/aura/src/lib.rs

@@ -105,9 +105,9 @@ pub mod pallet {
 				// TODO [#3398] Generate offence report for all authorities that skipped their
 				// slots.
 
-				T::DbWeight::get().reads_writes(2, 1)
+				Weight::from_computation(T::DbWeight::get().reads_writes(2, 1))
 			} else {
-				T::DbWeight::get().reads(1)
+				Weight::from_computation(T::DbWeight::get().reads(1))
 			}
 		}
 	}

frame/aura/src/migrations.rs

@@ -41,5 +41,5 @@ pub trait RemoveLastTimestamp: super::Config {
 /// This migration requires a type `T` that implements [`RemoveLastTimestamp`].
 pub fn remove_last_timestamp<T: RemoveLastTimestamp>() -> Weight {
 	LastTimestamp::<T>::kill();
-	T::DbWeight::get().writes(1)
+	Weight::from_computation(T::DbWeight::get().writes(1))
 }

frame/aura/src/mock.rs

@@ -49,7 +49,10 @@ frame_support::construct_runtime!(
 
 parameter_types! {
 	pub BlockWeights: frame_system::limits::BlockWeights =
-		frame_system::limits::BlockWeights::simple_max(1024);
+		frame_system::limits::BlockWeights::simple_max(frame_support::weights::Weight::new()
+			.set_computation(1024)
+			.set_bandwidth(1024)
+		);
 }
 
 impl frame_system::Config for Test {

frame/authority-discovery/src/lib.rs

@@ -227,7 +227,10 @@ mod tests {
 		pub const Period: BlockNumber = 1;
 		pub const Offset: BlockNumber = 0;
 		pub BlockWeights: frame_system::limits::BlockWeights =
-			frame_system::limits::BlockWeights::simple_max(1024);
+			frame_system::limits::BlockWeights::simple_max(frame_support::weights::Weight::new()
+				.set_computation(1024)
+				.set_bandwidth(1024)
+			);
 	}
 
 	impl frame_system::Config for Test {

frame/authorship/src/lib.rs

@@ -27,7 +27,7 @@ use frame_support::{
 	traits::{FindAuthor, Get, VerifySeal},
 };
 use sp_authorship::{InherentError, UnclesInherentData, INHERENT_IDENTIFIER};
-use sp_runtime::traits::{Header as HeaderT, One, Saturating};
+use sp_runtime::traits::{Header as HeaderT, One, Saturating, Zero};
 use sp_std::{collections::btree_set::BTreeSet, prelude::*, result};
 
 const MAX_UNCLES: usize = 10;
@@ -175,7 +175,7 @@ pub mod pallet {
 				T::EventHandler::note_author(author);
 			}
 
-			0
+			Weight::zero()
 		}
 
 		fn on_finalize(_: T::BlockNumber) {
@@ -434,7 +434,10 @@ mod tests {
 
 	parameter_types! {
 		pub BlockWeights: frame_system::limits::BlockWeights =
-			frame_system::limits::BlockWeights::simple_max(1024);
+			frame_system::limits::BlockWeights::simple_max(frame_support::weights::Weight::new()
+				.set_computation(1024)
+				.set_bandwidth(1024)
+			);
 	}
 
 	impl frame_system::Config for Test {