mirror of
https://github.com/pezkuwichain/pezkuwi-subxt.git
synced 2026-04-25 03:37:56 +00:00
Companion for Weight v1.5 (#1581)
* cargo test -p cumulus-primitives-utility
* cargo test -p cumulus-pallet-xcmp-queue
* cargo test -p cumulus-pallet-xcm
* cargo test -p cumulus-pallet-dmp-queue
* cargo test -p pallet-template
* cargo test -p cumulus-test-runtime
* fix weights
* fix more weights
* cargo test -p parachains-common
* cargo test -p parachain-template-runtime
* fix weights import
* cargo test -p collectives-polkadot-runtime
* cargo test -p contracts-rococo-runtime
* more
* unused
* fixes
* Update benchmarking.rs
* Update lib.rs
* Update lib.rs
* fix
* fix bug in conversion
* update lockfile for {"polkadot", "substrate"}
Co-authored-by: parity-processbot <>
This commit is contained in:
Shawn Tabrizi
@@ -140,7 +140,7 @@ pub mod pallet {
|
||||
///
|
||||
/// Events:
|
||||
/// - `OverweightServiced`: On success.
|
||||
#[pallet::weight(weight_limit.saturating_add(1_000_000))]
|
||||
#[pallet::weight(weight_limit.saturating_add(Weight::from_ref_time(1_000_000)))]
|
||||
pub fn service_overweight(
|
||||
origin: OriginFor<T>,
|
||||
index: OverweightIndex,
|
||||
@@ -153,7 +153,7 @@ pub mod pallet {
|
||||
.map_err(|_| Error::<T>::OverLimit)?;
|
||||
Overweight::<T>::remove(index);
|
||||
Self::deposit_event(Event::OverweightServiced { overweight_index: index, weight_used });
|
||||
Ok(Some(weight_used.saturating_add(1_000_000)).into())
|
||||
Ok(Some(weight_used.saturating_add(Weight::from_ref_time(1_000_000))).into())
|
||||
}
|
||||
}
|
||||
|
||||
@@ -189,7 +189,7 @@ pub mod pallet {
|
||||
/// Exactly equivalent to `service_queue` but expects a mutable `page_index` to be passed
|
||||
/// in and any changes stored.
|
||||
fn do_service_queue(limit: Weight, page_index: &mut PageIndexData) -> Weight {
|
||||
let mut used = 0;
|
||||
let mut used = Weight::new();
|
||||
while page_index.begin_used < page_index.end_used {
|
||||
let page = Pages::<T>::take(page_index.begin_used);
|
||||
for (i, &(sent_at, ref data)) in page.iter().enumerate() {
|
||||
@@ -232,19 +232,19 @@ pub mod pallet {
|
||||
match maybe_msg {
|
||||
Err(_) => {
|
||||
Self::deposit_event(Event::InvalidFormat { message_id });
|
||||
Ok(0)
|
||||
Ok(Weight::zero())
|
||||
},
|
||||
Ok(Err(())) => {
|
||||
Self::deposit_event(Event::UnsupportedVersion { message_id });
|
||||
Ok(0)
|
||||
Ok(Weight::zero())
|
||||
},
|
||||
Ok(Ok(x)) => {
|
||||
let outcome = T::XcmExecutor::execute_xcm(Parent, x, limit);
|
||||
let outcome = T::XcmExecutor::execute_xcm(Parent, x, limit.ref_time());
|
||||
match outcome {
|
||||
Outcome::Error(XcmError::WeightLimitReached(required)) =>
|
||||
Err((message_id, required)),
|
||||
Err((message_id, Weight::from_ref_time(required))),
|
||||
outcome => {
|
||||
let weight_used = outcome.weight_used();
|
||||
let weight_used = Weight::from_ref_time(outcome.weight_used());
|
||||
Self::deposit_event(Event::ExecutedDownward { message_id, outcome });
|
||||
Ok(weight_used)
|
||||
},
|
||||
@@ -349,7 +349,7 @@ mod tests {
|
||||
};
|
||||
use sp_version::RuntimeVersion;
|
||||
use std::cell::RefCell;
|
||||
use xcm::latest::{MultiLocation, OriginKind};
|
||||
use xcm::latest::{MultiLocation, OriginKind, Weight as XCMWeight};
|
||||
|
||||
type UncheckedExtrinsic = frame_system::mocking::MockUncheckedExtrinsic<Test>;
|
||||
type Block = frame_system::mocking::MockBlock<Test>;
|
||||
@@ -379,8 +379,8 @@ mod tests {
|
||||
state_version: 1,
|
||||
};
|
||||
pub const ParachainId: ParaId = ParaId::new(200);
|
||||
pub const ReservedXcmpWeight: Weight = 0;
|
||||
pub const ReservedDmpWeight: Weight = 0;
|
||||
pub const ReservedXcmpWeight: Weight = Weight::zero();
|
||||
pub const ReservedDmpWeight: Weight = Weight::zero();
|
||||
}
|
||||
|
||||
type AccountId = u64;
|
||||
@@ -429,8 +429,8 @@ mod tests {
|
||||
fn execute_xcm_in_credit(
|
||||
_origin: impl Into<MultiLocation>,
|
||||
message: Xcm,
|
||||
weight_limit: Weight,
|
||||
_credit: Weight,
|
||||
weight_limit: XCMWeight,
|
||||
_credit: XCMWeight,
|
||||
) -> Outcome {
|
||||
let o = match (message.0.len(), &message.0.first()) {
|
||||
(1, Some(Transact { require_weight_at_most, .. })) => {
|
||||
@@ -478,7 +478,7 @@ mod tests {
|
||||
DmpQueue::handle_dmp_messages(iter, limit)
|
||||
}
|
||||
|
||||
fn msg(weight: Weight) -> Xcm {
|
||||
fn msg(weight: XCMWeight) -> Xcm {
|
||||
Xcm(vec![Transact {
|
||||
origin_type: OriginKind::Native,
|
||||
require_weight_at_most: weight,
|
||||
@@ -486,11 +486,11 @@ mod tests {
|
||||
}])
|
||||
}
|
||||
|
||||
fn msg_complete(weight: Weight) -> (Xcm, Outcome) {
|
||||
fn msg_complete(weight: XCMWeight) -> (Xcm, Outcome) {
|
||||
(msg(weight), Outcome::Complete(weight))
|
||||
}
|
||||
|
||||
fn msg_limit_reached(weight: Weight) -> (Xcm, Outcome) {
|
||||
fn msg_limit_reached(weight: XCMWeight) -> (Xcm, Outcome) {
|
||||
(msg(weight), Outcome::Error(XcmError::WeightLimitReached(weight)))
|
||||
}
|
||||
|
||||
@@ -511,8 +511,8 @@ mod tests {
|
||||
#[test]
|
||||
fn basic_setup_works() {
|
||||
new_test_ext().execute_with(|| {
|
||||
let weight_used = handle_messages(&[], 1000);
|
||||
assert_eq!(weight_used, 0);
|
||||
let weight_used = handle_messages(&[], Weight::from_ref_time(1000));
|
||||
assert_eq!(weight_used, Weight::zero());
|
||||
assert_eq!(take_trace(), Vec::new());
|
||||
assert!(queue_is_empty());
|
||||
});
|
||||
@@ -522,8 +522,8 @@ mod tests {
|
||||
fn service_inline_complete_works() {
|
||||
new_test_ext().execute_with(|| {
|
||||
let incoming = vec![msg(1000), msg(1001)];
|
||||
let weight_used = handle_messages(&incoming, 2500);
|
||||
assert_eq!(weight_used, 2001);
|
||||
let weight_used = handle_messages(&incoming, Weight::from_ref_time(2500));
|
||||
assert_eq!(weight_used, Weight::from_ref_time(2001));
|
||||
assert_eq!(take_trace(), vec![msg_complete(1000), msg_complete(1001)]);
|
||||
assert!(queue_is_empty());
|
||||
});
|
||||
@@ -534,8 +534,8 @@ mod tests {
|
||||
new_test_ext().execute_with(|| {
|
||||
let enqueued = vec![msg(1000), msg(1001), msg(1002)];
|
||||
enqueue(&enqueued);
|
||||
let weight_used = handle_messages(&[], 2500);
|
||||
assert_eq!(weight_used, 2001);
|
||||
let weight_used = handle_messages(&[], Weight::from_ref_time(2500));
|
||||
assert_eq!(weight_used, Weight::from_ref_time(2001));
|
||||
assert_eq!(
|
||||
take_trace(),
|
||||
vec![msg_complete(1000), msg_complete(1001), msg_limit_reached(1002),]
|
||||
@@ -547,8 +547,8 @@ mod tests {
|
||||
fn enqueue_works() {
|
||||
new_test_ext().execute_with(|| {
|
||||
let incoming = vec![msg(1000), msg(1001), msg(1002)];
|
||||
let weight_used = handle_messages(&incoming, 999);
|
||||
assert_eq!(weight_used, 0);
|
||||
let weight_used = handle_messages(&incoming, Weight::from_ref_time(999));
|
||||
assert_eq!(weight_used, Weight::zero());
|
||||
assert_eq!(
|
||||
PageIndex::<Test>::get(),
|
||||
PageIndexData { begin_used: 0, end_used: 1, overweight_count: 0 }
|
||||
@@ -556,15 +556,15 @@ mod tests {
|
||||
assert_eq!(Pages::<Test>::get(0).len(), 3);
|
||||
assert_eq!(take_trace(), vec![msg_limit_reached(1000)]);
|
||||
|
||||
let weight_used = handle_messages(&[], 2500);
|
||||
assert_eq!(weight_used, 2001);
|
||||
let weight_used = handle_messages(&[], Weight::from_ref_time(2500));
|
||||
assert_eq!(weight_used, Weight::from_ref_time(2001));
|
||||
assert_eq!(
|
||||
take_trace(),
|
||||
vec![msg_complete(1000), msg_complete(1001), msg_limit_reached(1002),]
|
||||
);
|
||||
|
||||
let weight_used = handle_messages(&[], 2500);
|
||||
assert_eq!(weight_used, 1002);
|
||||
let weight_used = handle_messages(&[], Weight::from_ref_time(2500));
|
||||
assert_eq!(weight_used, Weight::from_ref_time(1002));
|
||||
assert_eq!(take_trace(), vec![msg_complete(1002),]);
|
||||
assert!(queue_is_empty());
|
||||
});
|
||||
@@ -574,14 +574,14 @@ mod tests {
|
||||
fn service_inline_then_enqueue_works() {
|
||||
new_test_ext().execute_with(|| {
|
||||
let incoming = vec![msg(1000), msg(1001), msg(1002)];
|
||||
let weight_used = handle_messages(&incoming, 1500);
|
||||
assert_eq!(weight_used, 1000);
|
||||
let weight_used = handle_messages(&incoming, Weight::from_ref_time(1500));
|
||||
assert_eq!(weight_used, Weight::from_ref_time(1000));
|
||||
assert_eq!(pages_queued(), 1);
|
||||
assert_eq!(Pages::<Test>::get(0).len(), 2);
|
||||
assert_eq!(take_trace(), vec![msg_complete(1000), msg_limit_reached(1001),]);
|
||||
|
||||
let weight_used = handle_messages(&[], 2500);
|
||||
assert_eq!(weight_used, 2003);
|
||||
let weight_used = handle_messages(&[], Weight::from_ref_time(2500));
|
||||
assert_eq!(weight_used, Weight::from_ref_time(2003));
|
||||
assert_eq!(take_trace(), vec![msg_complete(1001), msg_complete(1002),]);
|
||||
assert!(queue_is_empty());
|
||||
});
|
||||
@@ -593,8 +593,8 @@ mod tests {
|
||||
let enqueued = vec![msg(1000), msg(1001)];
|
||||
let incoming = vec![msg(1002), msg(1003)];
|
||||
enqueue(&enqueued);
|
||||
let weight_used = handle_messages(&incoming, 5000);
|
||||
assert_eq!(weight_used, 4006);
|
||||
let weight_used = handle_messages(&incoming, Weight::from_ref_time(5000));
|
||||
assert_eq!(weight_used, Weight::from_ref_time(4006));
|
||||
assert_eq!(
|
||||
take_trace(),
|
||||
vec![
|
||||
@@ -614,19 +614,19 @@ mod tests {
|
||||
let enqueued = vec![msg(1000), msg(10001)];
|
||||
let incoming = vec![msg(1002), msg(1003)];
|
||||
enqueue(&enqueued);
|
||||
let weight_used = handle_messages(&incoming, 5000);
|
||||
assert_eq!(weight_used, 1000);
|
||||
let weight_used = handle_messages(&incoming, Weight::from_ref_time(5000));
|
||||
assert_eq!(weight_used, Weight::from_ref_time(1000));
|
||||
assert_eq!(take_trace(), vec![msg_complete(1000), msg_limit_reached(10001),]);
|
||||
assert_eq!(pages_queued(), 2);
|
||||
|
||||
// 5000 is not enough to process the 10001 blocker, so nothing happens.
|
||||
let weight_used = handle_messages(&[], 5000);
|
||||
assert_eq!(weight_used, 0);
|
||||
let weight_used = handle_messages(&[], Weight::from_ref_time(5000));
|
||||
assert_eq!(weight_used, Weight::zero());
|
||||
assert_eq!(take_trace(), vec![msg_limit_reached(10001),]);
|
||||
|
||||
// 20000 is now enough to process everything.
|
||||
let weight_used = handle_messages(&[], 20000);
|
||||
assert_eq!(weight_used, 12006);
|
||||
let weight_used = handle_messages(&[], Weight::from_ref_time(20000));
|
||||
assert_eq!(weight_used, Weight::from_ref_time(12006));
|
||||
assert_eq!(
|
||||
take_trace(),
|
||||
vec![msg_complete(10001), msg_complete(1002), msg_complete(1003),]
|
||||
@@ -641,8 +641,8 @@ mod tests {
|
||||
let enqueued = vec![msg(1000), msg(1001)];
|
||||
let incoming = vec![msg(10002), msg(1003)];
|
||||
enqueue(&enqueued);
|
||||
let weight_used = handle_messages(&incoming, 5000);
|
||||
assert_eq!(weight_used, 2001);
|
||||
let weight_used = handle_messages(&incoming, Weight::from_ref_time(5000));
|
||||
assert_eq!(weight_used, Weight::from_ref_time(2001));
|
||||
assert_eq!(
|
||||
take_trace(),
|
||||
vec![msg_complete(1000), msg_complete(1001), msg_limit_reached(10002),]
|
||||
@@ -650,8 +650,8 @@ mod tests {
|
||||
assert_eq!(pages_queued(), 1);
|
||||
|
||||
// 20000 is now enough to process everything.
|
||||
let weight_used = handle_messages(&[], 20000);
|
||||
assert_eq!(weight_used, 11005);
|
||||
let weight_used = handle_messages(&[], Weight::from_ref_time(20000));
|
||||
assert_eq!(weight_used, Weight::from_ref_time(11005));
|
||||
assert_eq!(take_trace(), vec![msg_complete(10002), msg_complete(1003),]);
|
||||
assert!(queue_is_empty());
|
||||
});
|
||||
@@ -663,8 +663,8 @@ mod tests {
|
||||
let enqueued = vec![msg(1000), msg(1001)];
|
||||
let incoming = vec![msg(1002), msg(10003)];
|
||||
enqueue(&enqueued);
|
||||
let weight_used = handle_messages(&incoming, 5000);
|
||||
assert_eq!(weight_used, 3003);
|
||||
let weight_used = handle_messages(&incoming, Weight::from_ref_time(5000));
|
||||
assert_eq!(weight_used, Weight::from_ref_time(3003));
|
||||
assert_eq!(
|
||||
take_trace(),
|
||||
vec![
|
||||
@@ -677,8 +677,8 @@ mod tests {
|
||||
assert_eq!(pages_queued(), 1);
|
||||
|
||||
// 20000 is now enough to process everything.
|
||||
let weight_used = handle_messages(&[], 20000);
|
||||
assert_eq!(weight_used, 10003);
|
||||
let weight_used = handle_messages(&[], Weight::from_ref_time(20000));
|
||||
assert_eq!(weight_used, Weight::from_ref_time(10003));
|
||||
assert_eq!(take_trace(), vec![msg_complete(10003),]);
|
||||
assert!(queue_is_empty());
|
||||
});
|
||||
@@ -689,20 +689,20 @@ mod tests {
|
||||
new_test_ext().execute_with(|| {
|
||||
let enqueued = vec![msg(1000), msg(1001)];
|
||||
enqueue(&enqueued);
|
||||
let weight_used = handle_messages(&vec![msg(1002)], 1500);
|
||||
assert_eq!(weight_used, 1000);
|
||||
let weight_used = handle_messages(&vec![msg(1002)], Weight::from_ref_time(1500));
|
||||
assert_eq!(weight_used, Weight::from_ref_time(1000));
|
||||
assert_eq!(take_trace(), vec![msg_complete(1000), msg_limit_reached(1001),]);
|
||||
assert_eq!(pages_queued(), 2);
|
||||
assert_eq!(PageIndex::<Test>::get().begin_used, 0);
|
||||
|
||||
let weight_used = handle_messages(&vec![msg(1003)], 1500);
|
||||
assert_eq!(weight_used, 1001);
|
||||
let weight_used = handle_messages(&vec![msg(1003)], Weight::from_ref_time(1500));
|
||||
assert_eq!(weight_used, Weight::from_ref_time(1001));
|
||||
assert_eq!(take_trace(), vec![msg_complete(1001), msg_limit_reached(1002),]);
|
||||
assert_eq!(pages_queued(), 2);
|
||||
assert_eq!(PageIndex::<Test>::get().begin_used, 1);
|
||||
|
||||
let weight_used = handle_messages(&vec![msg(1004)], 1500);
|
||||
assert_eq!(weight_used, 1002);
|
||||
let weight_used = handle_messages(&vec![msg(1004)], Weight::from_ref_time(1500));
|
||||
assert_eq!(weight_used, Weight::from_ref_time(1002));
|
||||
assert_eq!(take_trace(), vec![msg_complete(1002), msg_limit_reached(1003),]);
|
||||
assert_eq!(pages_queued(), 2);
|
||||
assert_eq!(PageIndex::<Test>::get().begin_used, 2);
|
||||
@@ -713,11 +713,11 @@ mod tests {
|
||||
fn overweight_should_not_block_queue() {
|
||||
new_test_ext().execute_with(|| {
|
||||
// Set the overweight threshold to 9999.
|
||||
Configuration::<Test>::put(ConfigData { max_individual: 9999 });
|
||||
Configuration::<Test>::put(ConfigData { max_individual: Weight::from_ref_time(9999) });
|
||||
|
||||
let incoming = vec![msg(1000), msg(10001), msg(1002)];
|
||||
let weight_used = handle_messages(&incoming, 2500);
|
||||
assert_eq!(weight_used, 2002);
|
||||
let weight_used = handle_messages(&incoming, Weight::from_ref_time(2500));
|
||||
assert_eq!(weight_used, Weight::from_ref_time(2002));
|
||||
assert!(queue_is_empty());
|
||||
assert_eq!(
|
||||
take_trace(),
|
||||
@@ -732,37 +732,43 @@ mod tests {
|
||||
fn overweights_should_be_manually_executable() {
|
||||
new_test_ext().execute_with(|| {
|
||||
// Set the overweight threshold to 9999.
|
||||
Configuration::<Test>::put(ConfigData { max_individual: 9999 });
|
||||
Configuration::<Test>::put(ConfigData { max_individual: Weight::from_ref_time(9999) });
|
||||
|
||||
let incoming = vec![msg(10000)];
|
||||
let weight_used = handle_messages(&incoming, 2500);
|
||||
assert_eq!(weight_used, 0);
|
||||
let weight_used = handle_messages(&incoming, Weight::from_ref_time(2500));
|
||||
assert_eq!(weight_used, Weight::zero());
|
||||
assert_eq!(take_trace(), vec![msg_limit_reached(10000)]);
|
||||
assert_eq!(overweights(), vec![0]);
|
||||
|
||||
assert_noop!(DmpQueue::service_overweight(Origin::signed(1), 0, 20000), BadOrigin);
|
||||
assert_noop!(
|
||||
DmpQueue::service_overweight(Origin::root(), 1, 20000),
|
||||
DmpQueue::service_overweight(Origin::signed(1), 0, Weight::from_ref_time(20000)),
|
||||
BadOrigin
|
||||
);
|
||||
assert_noop!(
|
||||
DmpQueue::service_overweight(Origin::root(), 1, Weight::from_ref_time(20000)),
|
||||
Error::<Test>::Unknown
|
||||
);
|
||||
assert_noop!(
|
||||
DmpQueue::service_overweight(Origin::root(), 0, 9999),
|
||||
DmpQueue::service_overweight(Origin::root(), 0, Weight::from_ref_time(9999)),
|
||||
Error::<Test>::OverLimit
|
||||
);
|
||||
assert_eq!(take_trace(), vec![msg_limit_reached(10000)]);
|
||||
|
||||
let base_weight = super::Call::<Test>::service_overweight { index: 0, weight_limit: 0 }
|
||||
.get_dispatch_info()
|
||||
.weight;
|
||||
let base_weight =
|
||||
super::Call::<Test>::service_overweight { index: 0, weight_limit: Weight::zero() }
|
||||
.get_dispatch_info()
|
||||
.weight;
|
||||
use frame_support::weights::GetDispatchInfo;
|
||||
let info = DmpQueue::service_overweight(Origin::root(), 0, 20000).unwrap();
|
||||
let info =
|
||||
DmpQueue::service_overweight(Origin::root(), 0, Weight::from_ref_time(20000))
|
||||
.unwrap();
|
||||
let actual_weight = info.actual_weight.unwrap();
|
||||
assert_eq!(actual_weight, base_weight + 10000);
|
||||
assert_eq!(actual_weight, base_weight + Weight::from_ref_time(10000));
|
||||
assert_eq!(take_trace(), vec![msg_complete(10000)]);
|
||||
assert!(overweights().is_empty());
|
||||
|
||||
assert_noop!(
|
||||
DmpQueue::service_overweight(Origin::root(), 0, 20000),
|
||||
DmpQueue::service_overweight(Origin::root(), 0, Weight::from_ref_time(20000)),
|
||||
Error::<Test>::Unknown
|
||||
);
|
||||
});
|
||||
@@ -775,8 +781,8 @@ mod tests {
|
||||
enqueue(&vec![msg(1002), msg(1003)]);
|
||||
enqueue(&vec![msg(1004), msg(1005)]);
|
||||
|
||||
let weight_used = DmpQueue::on_idle(1, 6000);
|
||||
assert_eq!(weight_used, 5010);
|
||||
let weight_used = DmpQueue::on_idle(1, Weight::from_ref_time(6000));
|
||||
assert_eq!(weight_used, Weight::from_ref_time(5010));
|
||||
assert_eq!(
|
||||
take_trace(),
|
||||
vec![
|
||||
|
||||
Reference in New Issue
Block a user