pezkuwichain/pezkuwi-subxt
1
0
Fork 0
mirror of https://github.com/pezkuwichain/pezkuwi-subxt.git synced 2026-05-31 06:21:02 +00:00
Code Issues Packages Projects Releases Wiki Activity

Remove AssignmentProviderConfig and use parameters from HostConfiguration instead (#3181)

Browse Source 
This PR removes `AssignmentProviderConfig` and uses the corresponding
ondemand parameters from `HostConfiguration` instead. Additionally
`scheduling_lookahead` and all coretime/ondemand related parameters are
extracted in a separate struct - `SchedulerParams`.

The most relevant commit from the PR is [this
one](https://github.com/paritytech/polkadot-sdk/pull/3181/commits/830bc0f5e858944474171bbe33382ad96040b535).

Fixes https://github.com/paritytech/polkadot-sdk/issues/2268

---------

Co-authored-by: command-bot <>
This commit is contained in:
Tsvetomir Dimitrov
2024-02-29 09:12:02 +02:00
committed by GitHub
parent a22319cdd5
commit a035dc9be7
43 changed files with 900 additions and 438 deletions
Download Patch File Download Diff File Expand all files Collapse all files
cumulus/zombienet/tests/0002-pov_recovery.toml
+1 -1
View File
@@ -4,7 +4,7 @@ default_command = "polkadot"
chain = "rococo-local"
[relaychain.genesis.runtimeGenesis.patch.configuration.config]
[relaychain.genesis.runtimeGenesis.patch.configuration.config.scheduler_params]
# set parameters such that collators only connect to 1 validator as a backing group
max_validators_per_core = 1
group_rotation_frequency = 100 # 10 mins
polkadot/node/service/src/chain_spec.rs
+11 -3
View File
@@ -24,6 +24,8 @@ use polkadot_primitives::{AccountId, AccountPublic, AssignmentId, ValidatorId};
use sp_authority_discovery::AuthorityId as AuthorityDiscoveryId;
use sp_consensus_babe::AuthorityId as BabeId;
#[cfg(any(feature = "rococo-native", feature = "westend-native",))]
use polkadot_primitives::vstaging::SchedulerParams;
#[cfg(feature = "rococo-native")]
use rococo_runtime as rococo;
#[cfg(feature = "rococo-native")]
@@ -129,8 +131,6 @@ fn default_parachains_host_configuration(
max_code_size: MAX_CODE_SIZE,
max_pov_size: MAX_POV_SIZE,
max_head_data_size: 32 * 1024,
group_rotation_frequency: 20,
paras_availability_period: 4,
max_upward_queue_count: 8,
max_upward_queue_size: 1024 * 1024,
max_downward_message_size: 1024 * 1024,
@@ -151,11 +151,16 @@ fn default_parachains_host_configuration(
relay_vrf_modulo_samples: 2,
zeroth_delay_tranche_width: 0,
minimum_validation_upgrade_delay: 5,
scheduling_lookahead: 2,
async_backing_params: AsyncBackingParams {
max_candidate_depth: 3,
allowed_ancestry_len: 2,
},
scheduler_params: SchedulerParams {
lookahead: 2,
group_rotation_frequency: 20,
paras_availability_period: 4,
..Default::default()
},
..Default::default()
}
}
@@ -891,7 +896,10 @@ pub fn rococo_testnet_genesis(
"sudo": { "key": Some(root_key.clone()) },
"configuration": {
"config": polkadot_runtime_parachains::configuration::HostConfiguration {
scheduler_params: SchedulerParams {
max_validators_per_core: Some(1),
..default_parachains_host_configuration().scheduler_params
},
..default_parachains_host_configuration()
},
},
polkadot/node/test/service/src/chain_spec.rs
+8 -3
View File
@@ -19,7 +19,9 @@
use babe_primitives::AuthorityId as BabeId;
use grandpa::AuthorityId as GrandpaId;
use pallet_staking::Forcing;
use polkadot_primitives::{AccountId, AssignmentId, ValidatorId, MAX_CODE_SIZE, MAX_POV_SIZE};
use polkadot_primitives::{
vstaging::SchedulerParams, AccountId, AssignmentId, ValidatorId, MAX_CODE_SIZE, MAX_POV_SIZE,
};
use polkadot_service::chain_spec::{get_account_id_from_seed, get_from_seed, Extensions};
use polkadot_test_runtime::BABE_GENESIS_EPOCH_CONFIG;
use sc_chain_spec::{ChainSpec, ChainType};
@@ -165,11 +167,14 @@ fn polkadot_testnet_genesis(
max_code_size: MAX_CODE_SIZE,
max_pov_size: MAX_POV_SIZE,
max_head_data_size: 32 * 1024,
group_rotation_frequency: 20,
paras_availability_period: 4,
no_show_slots: 10,
minimum_validation_upgrade_delay: 5,
max_downward_message_size: 1024,
scheduler_params: SchedulerParams {
group_rotation_frequency: 20,
paras_availability_period: 4,
..Default::default()
},
..Default::default()
},
}
polkadot/primitives/src/vstaging/mod.rs
+76
View File
@@ -23,6 +23,7 @@ use sp_std::prelude::*;
use parity_scale_codec::{Decode, Encode};
use primitives::RuntimeDebug;
use scale_info::TypeInfo;
use sp_arithmetic::Perbill;
/// Approval voting configuration parameters
#[derive(
@@ -50,6 +51,81 @@ impl Default for ApprovalVotingParams {
}
}
/// Scheduler configuration parameters. All coretime/ondemand parameters are here.
#[derive(
RuntimeDebug,
Copy,
Clone,
PartialEq,
Encode,
Decode,
TypeInfo,
serde::Serialize,
serde::Deserialize,
)]
pub struct SchedulerParams<BlockNumber> {
/// How often parachain groups should be rotated across parachains.
///
/// Must be non-zero.
pub group_rotation_frequency: BlockNumber,
/// Availability timeout for a block on a core, measured in blocks.
///
/// This is the maximum amount of blocks after a core became occupied that validators have time
/// to make the block available.
///
/// This value only has effect on group rotations. If backers backed something at the end of
/// their rotation, the occupied core affects the backing group that comes afterwards. We limit
/// the effect one backing group can have on the next to `paras_availability_period` blocks.
///
/// Within a group rotation there is no timeout as backers are only affecting themselves.
///
/// Must be at least 1. With a value of 1, the previous group will not be able to negatively
/// affect the following group at the expense of a tight availability timeline at group
/// rotation boundaries.
pub paras_availability_period: BlockNumber,
/// The maximum number of validators to have per core.
///
/// `None` means no maximum.
pub max_validators_per_core: Option<u32>,
/// The amount of blocks ahead to schedule paras.
pub lookahead: u32,
/// How many cores are managed by the coretime chain.
pub num_cores: u32,
/// The max number of times a claim can time out in availability.
pub max_availability_timeouts: u32,
/// The maximum queue size of the pay as you go module.
pub on_demand_queue_max_size: u32,
/// The target utilization of the spot price queue in percentages.
pub on_demand_target_queue_utilization: Perbill,
/// How quickly the fee rises in reaction to increased utilization.
/// The lower the number the slower the increase.
pub on_demand_fee_variability: Perbill,
/// The minimum amount needed to claim a slot in the spot pricing queue.
pub on_demand_base_fee: Balance,
/// The number of blocks a claim stays in the scheduler's claimqueue before getting cleared.
/// This number should go reasonably higher than the number of blocks in the async backing
/// lookahead.
pub ttl: BlockNumber,
}
impl<BlockNumber: Default + From<u32>> Default for SchedulerParams<BlockNumber> {
fn default() -> Self {
Self {
group_rotation_frequency: 1u32.into(),
paras_availability_period: 1u32.into(),
max_validators_per_core: Default::default(),
lookahead: 1,
num_cores: Default::default(),
max_availability_timeouts: Default::default(),
on_demand_queue_max_size: ON_DEMAND_DEFAULT_QUEUE_MAX_SIZE,
on_demand_target_queue_utilization: Perbill::from_percent(25),
on_demand_fee_variability: Perbill::from_percent(3),
on_demand_base_fee: 10_000_000u128,
ttl: 5u32.into(),
}
}
}
use bitvec::vec::BitVec;
/// Bit indices in the `HostConfiguration.node_features` that correspond to different node features.
polkadot/roadmap/implementers-guide/src/types/runtime.md
+17 -99
View File
@@ -4,106 +4,24 @@ Types used within the runtime exclusively and pervasively.
## Host Configuration
The internal-to-runtime configuration of the parachain host. This is expected to be altered only by governance procedures.
The internal-to-runtime configuration of the parachain host is kept in `struct HostConfiguration`. This is expected to
be altered only by governance procedures or via migrations from the Polkadot-SDK codebase. The latest definition of
`HostConfiguration` can be found in the project repo
[here](https://github.com/paritytech/polkadot-sdk/blob/master/polkadot/runtime/parachains/src/configuration.rs). Each
parameter has got a doc comment so for any details please refer to the code.
```rust
struct HostConfiguration {
/// The minimum period, in blocks, between which parachains can update their validation code.
pub validation_upgrade_cooldown: BlockNumber,
/// The delay, in blocks, before a validation upgrade is applied.
pub validation_upgrade_delay: BlockNumber,
/// How long to keep code on-chain, in blocks. This should be sufficiently long that disputes
/// have concluded.
pub code_retention_period: BlockNumber,
/// The maximum validation code size, in bytes.
pub max_code_size: u32,
/// The maximum head-data size, in bytes.
pub max_head_data_size: u32,
/// The amount of availability cores to dedicate to parathreads (on-demand parachains).
pub parathread_cores: u32,
/// The number of retries that a parathread (on-demand parachain) author has to submit their block.
pub parathread_retries: u32,
/// How often parachain groups should be rotated across parachains.
pub group_rotation_frequency: BlockNumber,
/// The availability period, in blocks, for parachains. This is the amount of blocks
/// after inclusion that validators have to make the block available and signal its availability to
/// the chain. Must be at least 1.
pub chain_availability_period: BlockNumber,
/// The availability period, in blocks, for parathreads (on-demand parachains). Same as the `chain_availability_period`,
/// but a differing timeout due to differing requirements. Must be at least 1.
pub thread_availability_period: BlockNumber,
/// The amount of blocks ahead to schedule on-demand parachains.
pub scheduling_lookahead: u32,
/// The maximum number of validators to have per core. `None` means no maximum.
pub max_validators_per_core: Option<u32>,
/// The maximum number of validators to use for parachains, in total. `None` means no maximum.
pub max_validators: Option<u32>,
/// The amount of sessions to keep for disputes.
pub dispute_period: SessionIndex,
/// How long after dispute conclusion to accept statements.
pub dispute_post_conclusion_acceptance_period: BlockNumber,
/// The maximum number of dispute spam slots
pub dispute_max_spam_slots: u32,
/// The amount of consensus slots that must pass between submitting an assignment and
/// submitting an approval vote before a validator is considered a no-show.
/// Must be at least 1.
pub no_show_slots: u32,
/// The number of delay tranches in total.
pub n_delay_tranches: u32,
/// The width of the zeroth delay tranche for approval assignments. This many delay tranches
/// beyond 0 are all consolidated to form a wide 0 tranche.
pub zeroth_delay_tranche_width: u32,
/// The number of validators needed to approve a block.
pub needed_approvals: u32,
/// The number of samples to use in `RelayVRFModulo` or `RelayVRFModuloCompact` approval assignment criterions.
pub relay_vrf_modulo_samples: u32,
/// Total number of individual messages allowed in the parachain -> relay-chain message queue.
pub max_upward_queue_count: u32,
/// Total size of messages allowed in the parachain -> relay-chain message queue before which
/// no further messages may be added to it. If it exceeds this then the queue may contain only
/// a single message.
pub max_upward_queue_size: u32,
/// The maximum size of an upward message that can be sent by a candidate.
///
/// This parameter affects the upper bound of size of `CandidateCommitments`.
pub max_upward_message_size: u32,
/// The maximum number of messages that a candidate can contain.
///
/// This parameter affects the upper bound of size of `CandidateCommitments`.
pub max_upward_message_num_per_candidate: u32,
/// The maximum size of a message that can be put in a downward message queue.
///
/// Since we require receiving at least one DMP message the obvious upper bound of the size is
/// the PoV size. Of course, there is a lot of other different things that a parachain may
/// decide to do with its PoV so this value in practice will be picked as a fraction of the PoV
/// size.
pub max_downward_message_size: u32,
/// The deposit that the sender should provide for opening an HRMP channel.
pub hrmp_sender_deposit: u32,
/// The deposit that the recipient should provide for accepting opening an HRMP channel.
pub hrmp_recipient_deposit: u32,
/// The maximum number of messages allowed in an HRMP channel at once.
pub hrmp_channel_max_capacity: u32,
/// The maximum total size of messages in bytes allowed in an HRMP channel at once.
pub hrmp_channel_max_total_size: u32,
/// The maximum number of inbound HRMP channels a parachain is allowed to accept.
pub hrmp_max_parachain_inbound_channels: u32,
/// The maximum number of inbound HRMP channels a parathread (on-demand parachain) is allowed to accept.
pub hrmp_max_parathread_inbound_channels: u32,
/// The maximum size of a message that could ever be put into an HRMP channel.
///
/// This parameter affects the upper bound of size of `CandidateCommitments`.
pub hrmp_channel_max_message_size: u32,
/// The maximum number of outbound HRMP channels a parachain is allowed to open.
pub hrmp_max_parachain_outbound_channels: u32,
/// The maximum number of outbound HRMP channels a parathread (on-demand parachain) is allowed to open.
pub hrmp_max_parathread_outbound_channels: u32,
/// The maximum number of outbound HRMP messages can be sent by a candidate.
///
/// This parameter affects the upper bound of size of `CandidateCommitments`.
pub hrmp_max_message_num_per_candidate: u32,
}
```
Some related parameters in `HostConfiguration` are grouped together so that they can be managed easily. These are:
* `async_backing_params` in `struct AsyncBackingParams`
* `executor_params` in `struct ExecutorParams`
* `approval_voting_params` in `struct ApprovalVotingParams`
* `scheduler_params` in `struct SchedulerParams`
Check the definitions of these structs for further details.
### Configuration migrations
Modifying `HostConfiguration` requires a storage migration. These migrations are located in the
[`migrations`](https://github.com/paritytech/polkadot-sdk/blob/master/polkadot/runtime/parachains/src/configuration.rs)
subfolder of Polkadot-SDK repo.
## ParaInherentData
polkadot/runtime/parachains/src/assigner_coretime/mock_helpers.rs
+6 -5
View File
@@ -64,11 +64,12 @@ impl GenesisConfigBuilder {
pub(super) fn build(self) -> MockGenesisConfig {
let mut genesis = default_genesis_config();
let config = &mut genesis.configuration.config;
config.coretime_cores = self.on_demand_cores;
config.on_demand_base_fee = self.on_demand_base_fee;
config.on_demand_fee_variability = self.on_demand_fee_variability;
config.on_demand_queue_max_size = self.on_demand_max_queue_size;
config.on_demand_target_queue_utilization = self.on_demand_target_queue_utilization;
config.scheduler_params.num_cores = self.on_demand_cores;
config.scheduler_params.on_demand_base_fee = self.on_demand_base_fee;
config.scheduler_params.on_demand_fee_variability = self.on_demand_fee_variability;
config.scheduler_params.on_demand_queue_max_size = self.on_demand_max_queue_size;
config.scheduler_params.on_demand_target_queue_utilization =
self.on_demand_target_queue_utilization;
let paras = &mut genesis.paras.paras;
for para_id in self.onboarded_on_demand_chains {
polkadot/runtime/parachains/src/assigner_coretime/mod.rs
+4 -12
View File
@@ -30,7 +30,7 @@ mod tests;
use crate::{
assigner_on_demand, configuration,
paras::AssignCoretime,
scheduler::common::{Assignment, AssignmentProvider, AssignmentProviderConfig},
scheduler::common::{Assignment, AssignmentProvider},
ParaId,
};
@@ -316,14 +316,6 @@ impl<T: Config> AssignmentProvider<BlockNumberFor<T>> for Pallet<T> {
}
}
fn get_provider_config(_core_idx: CoreIndex) -> AssignmentProviderConfig<BlockNumberFor<T>> {
let config = <configuration::Pallet<T>>::config();
AssignmentProviderConfig {
max_availability_timeouts: config.on_demand_retries,
ttl: config.on_demand_ttl,
}
}
#[cfg(any(feature = "runtime-benchmarks", test))]
fn get_mock_assignment(_: CoreIndex, para_id: primitives::Id) -> Assignment {
// Given that we are not tracking anything in `Bulk` assignments, it is safe to always
@@ -333,7 +325,7 @@ impl<T: Config> AssignmentProvider<BlockNumberFor<T>> for Pallet<T> {
fn session_core_count() -> u32 {
let config = <configuration::Pallet<T>>::config();
config.coretime_cores
config.scheduler_params.num_cores
}
}
@@ -482,8 +474,8 @@ impl<T: Config> AssignCoretime for Pallet<T> {
// Add a new core and assign the para to it.
let mut config = <configuration::Pallet<T>>::config();
let core = config.coretime_cores;
config.coretime_cores.saturating_inc();
let core = config.scheduler_params.num_cores;
config.scheduler_params.num_cores.saturating_inc();
// `assign_coretime` is only called at genesis or by root, so setting the active
// config here is fine.
polkadot/runtime/parachains/src/assigner_on_demand/benchmarking.rs
+1 -1
View File
@@ -43,7 +43,7 @@ where
{
ParasShared::<T>::set_session_index(SESSION_INDEX);
let mut config = HostConfiguration::default();
config.coretime_cores = 1;
config.scheduler_params.num_cores = 1;
ConfigurationPallet::<T>::force_set_active_config(config);
let mut parachains = ParachainsCache::new();
ParasPallet::<T>::initialize_para_now(
polkadot/runtime/parachains/src/assigner_on_demand/mock_helpers.rs
+6 -5
View File
@@ -63,11 +63,12 @@ impl GenesisConfigBuilder {
pub(super) fn build(self) -> MockGenesisConfig {
let mut genesis = default_genesis_config();
let config = &mut genesis.configuration.config;
config.coretime_cores = self.on_demand_cores;
config.on_demand_base_fee = self.on_demand_base_fee;
config.on_demand_fee_variability = self.on_demand_fee_variability;
config.on_demand_queue_max_size = self.on_demand_max_queue_size;
config.on_demand_target_queue_utilization = self.on_demand_target_queue_utilization;
config.scheduler_params.num_cores = self.on_demand_cores;
config.scheduler_params.on_demand_base_fee = self.on_demand_base_fee;
config.scheduler_params.on_demand_fee_variability = self.on_demand_fee_variability;
config.scheduler_params.on_demand_queue_max_size = self.on_demand_max_queue_size;
config.scheduler_params.on_demand_target_queue_utilization =
self.on_demand_target_queue_utilization;
let paras = &mut genesis.paras.paras;
for para_id in self.onboarded_on_demand_chains {
polkadot/runtime/parachains/src/assigner_on_demand/mod.rs
+11 -7
View File
@@ -201,10 +201,10 @@ pub mod pallet {
let old_traffic = SpotTraffic::<T>::get();
match Self::calculate_spot_traffic(
old_traffic,
config.on_demand_queue_max_size,
config.scheduler_params.on_demand_queue_max_size,
Self::queue_size(),
config.on_demand_target_queue_utilization,
config.on_demand_fee_variability,
config.scheduler_params.on_demand_target_queue_utilization,
config.scheduler_params.on_demand_fee_variability,
) {
Ok(new_traffic) => {
// Only update storage on change
@@ -330,8 +330,9 @@ where
let traffic = SpotTraffic::<T>::get();
// Calculate spot price
let spot_price: BalanceOf<T> =
traffic.saturating_mul_int(config.on_demand_base_fee.saturated_into::<BalanceOf<T>>());
let spot_price: BalanceOf<T> = traffic.saturating_mul_int(
config.scheduler_params.on_demand_base_fee.saturated_into::<BalanceOf<T>>(),
);
// Is the current price higher than `max_amount`
ensure!(spot_price.le(&max_amount), Error::<T>::SpotPriceHigherThanMaxAmount);
@@ -450,7 +451,10 @@ where
OnDemandQueue::<T>::try_mutate(|queue| {
// Abort transaction if queue is too large
ensure!(Self::queue_size() < config.on_demand_queue_max_size, Error::<T>::QueueFull);
ensure!(
Self::queue_size() < config.scheduler_params.on_demand_queue_max_size,
Error::<T>::QueueFull
);
match location {
QueuePushDirection::Back => queue.push_back(order),
QueuePushDirection::Front => queue.push_front(order),
@@ -472,7 +476,7 @@ where
target: LOG_TARGET,
"Failed to fetch the on demand queue size, returning the max size."
);
return config.on_demand_queue_max_size
return config.scheduler_params.on_demand_queue_max_size
},
}
}
polkadot/runtime/parachains/src/assigner_parachains.rs
+1 -11
View File
@@ -27,7 +27,7 @@ use primitives::CoreIndex;
use crate::{
configuration, paras,
scheduler::common::{Assignment, AssignmentProvider, AssignmentProviderConfig},
scheduler::common::{Assignment, AssignmentProvider},
};
pub use pallet::*;
@@ -58,16 +58,6 @@ impl<T: Config> AssignmentProvider<BlockNumberFor<T>> for Pallet<T> {
/// this is a no-op in the case of a bulk assignment slot.
fn push_back_assignment(_: Assignment) {}
fn get_provider_config(_core_idx: CoreIndex) -> AssignmentProviderConfig<BlockNumberFor<T>> {
AssignmentProviderConfig {
// The next assignment already goes to the same [`ParaId`], no timeout tracking needed.
max_availability_timeouts: 0,
// The next assignment already goes to the same [`ParaId`], this can be any number
// that's high enough to clear the time it takes to clear backing/availability.
ttl: 10u32.into(),
}
}
#[cfg(any(feature = "runtime-benchmarks", test))]
fn get_mock_assignment(_: CoreIndex, para_id: primitives::Id) -> Assignment {
Assignment::Bulk(para_id)
polkadot/runtime/parachains/src/assigner_parachains/mock_helpers.rs
+6 -5
View File
@@ -60,11 +60,12 @@ impl GenesisConfigBuilder {
pub(super) fn build(self) -> MockGenesisConfig {
let mut genesis = default_genesis_config();
let config = &mut genesis.configuration.config;
config.coretime_cores = self.on_demand_cores;
config.on_demand_base_fee = self.on_demand_base_fee;
config.on_demand_fee_variability = self.on_demand_fee_variability;
config.on_demand_queue_max_size = self.on_demand_max_queue_size;
config.on_demand_target_queue_utilization = self.on_demand_target_queue_utilization;
config.scheduler_params.num_cores = self.on_demand_cores;
config.scheduler_params.on_demand_base_fee = self.on_demand_base_fee;
config.scheduler_params.on_demand_fee_variability = self.on_demand_fee_variability;
config.scheduler_params.on_demand_queue_max_size = self.on_demand_max_queue_size;
config.scheduler_params.on_demand_target_queue_utilization =
self.on_demand_target_queue_utilization;
let paras = &mut genesis.paras.paras;
for para_id in self.onboarded_on_demand_chains {
polkadot/runtime/parachains/src/builder.rs
+8 -11
View File
@@ -18,11 +18,7 @@ use crate::{
configuration, inclusion, initializer, paras,
paras::ParaKind,
paras_inherent,
scheduler::{
self,
common::{AssignmentProvider, AssignmentProviderConfig},
CoreOccupied, ParasEntry,
},
scheduler::{self, common::AssignmentProvider, CoreOccupied, ParasEntry},
session_info, shared,
};
use bitvec::{order::Lsb0 as BitOrderLsb0, vec::BitVec};
@@ -197,7 +193,10 @@ impl<T: paras_inherent::Config> BenchBuilder<T> {
/// Maximum number of validators per core (a.k.a. max validators per group). This value is used
/// if none is explicitly set on the builder.
pub(crate) fn fallback_max_validators_per_core() -> u32 {
configuration::Pallet::<T>::config().max_validators_per_core.unwrap_or(5)
configuration::Pallet::<T>::config()
.scheduler_params
.max_validators_per_core
.unwrap_or(5)
}
/// Specify a mapping of core index/ para id to the number of dispute statements for the
@@ -684,7 +683,7 @@ impl<T: paras_inherent::Config> BenchBuilder<T> {
// We are currently in Session 0, so these changes will take effect in Session 2.
Self::setup_para_ids(used_cores);
configuration::ActiveConfig::<T>::mutate(|c| {
c.coretime_cores = used_cores;
c.scheduler_params.num_cores = used_cores;
});
let validator_ids = Self::generate_validator_pairs(self.max_validators());
@@ -715,8 +714,7 @@ impl<T: paras_inherent::Config> BenchBuilder<T> {
let cores = (0..used_cores)
.into_iter()
.map(|i| {
let AssignmentProviderConfig { ttl, .. } =
scheduler::Pallet::<T>::assignment_provider_config(CoreIndex(i));
let ttl = configuration::Pallet::<T>::config().scheduler_params.ttl;
// Load an assignment into provider so that one is present to pop
let assignment = <T as scheduler::Config>::AssignmentProvider::get_mock_assignment(
CoreIndex(i),
@@ -731,8 +729,7 @@ impl<T: paras_inherent::Config> BenchBuilder<T> {
let cores = (0..used_cores)
.into_iter()
.map(|i| {
let AssignmentProviderConfig { ttl, .. } =
scheduler::Pallet::<T>::assignment_provider_config(CoreIndex(i));
let ttl = configuration::Pallet::<T>::config().scheduler_params.ttl;
// Load an assignment into provider so that one is present to pop
let assignment =
<T as scheduler::Config>::AssignmentProvider::get_mock_assignment(
polkadot/runtime/parachains/src/configuration.rs
+56 -77
View File
@@ -29,7 +29,6 @@ use primitives::{
vstaging::{ApprovalVotingParams, NodeFeatures},
AsyncBackingParams, Balance, ExecutorParamError, ExecutorParams, SessionIndex,
LEGACY_MIN_BACKING_VOTES, MAX_CODE_SIZE, MAX_HEAD_DATA_SIZE, MAX_POV_SIZE,
ON_DEMAND_DEFAULT_QUEUE_MAX_SIZE,
};
use sp_runtime::{traits::Zero, Perbill};
use sp_std::prelude::*;
@@ -43,6 +42,7 @@ mod benchmarking;
pub mod migration;
pub use pallet::*;
use primitives::vstaging::SchedulerParams;
const LOG_TARGET: &str = "runtime::configuration";
@@ -118,9 +118,9 @@ pub struct HostConfiguration<BlockNumber> {
/// been completed.
///
/// Note, there are situations in which `expected_at` in the past. For example, if
/// [`paras_availability_period`](Self::paras_availability_period) is less than the delay set
/// by this field or if PVF pre-check took more time than the delay. In such cases, the upgrade
/// is further at the earliest possible time determined by
/// [`paras_availability_period`](SchedulerParams::paras_availability_period) is less than the
/// delay set by this field or if PVF pre-check took more time than the delay. In such cases,
/// the upgrade is further at the earliest possible time determined by
/// [`minimum_validation_upgrade_delay`](Self::minimum_validation_upgrade_delay).
///
/// The rationale for this delay has to do with relay-chain reversions. In case there is an
@@ -172,48 +172,7 @@ pub struct HostConfiguration<BlockNumber> {
/// How long to keep code on-chain, in blocks. This should be sufficiently long that disputes
/// have concluded.
pub code_retention_period: BlockNumber,
/// How many cores are managed by the coretime chain.
pub coretime_cores: u32,
/// The number of retries that a on demand author has to submit their block.
pub on_demand_retries: u32,
/// The maximum queue size of the pay as you go module.
pub on_demand_queue_max_size: u32,
/// The target utilization of the spot price queue in percentages.
pub on_demand_target_queue_utilization: Perbill,
/// How quickly the fee rises in reaction to increased utilization.
/// The lower the number the slower the increase.
pub on_demand_fee_variability: Perbill,
/// The minimum amount needed to claim a slot in the spot pricing queue.
pub on_demand_base_fee: Balance,
/// The number of blocks an on demand claim stays in the scheduler's claimqueue before getting
/// cleared. This number should go reasonably higher than the number of blocks in the async
/// backing lookahead.
pub on_demand_ttl: BlockNumber,
/// How often parachain groups should be rotated across parachains.
///
/// Must be non-zero.
pub group_rotation_frequency: BlockNumber,
/// The minimum availability period, in blocks.
///
/// This is the minimum amount of blocks after a core became occupied that validators have time
/// to make the block available.
///
/// This value only has effect on group rotations. If backers backed something at the end of
/// their rotation, the occupied core affects the backing group that comes afterwards. We limit
/// the effect one backing group can have on the next to `paras_availability_period` blocks.
///
/// Within a group rotation there is no timeout as backers are only affecting themselves.
///
/// Must be at least 1. With a value of 1, the previous group will not be able to negatively
/// affect the following group at the expense of a tight availability timeline at group
/// rotation boundaries.
pub paras_availability_period: BlockNumber,
/// The amount of blocks ahead to schedule paras.
pub scheduling_lookahead: u32,
/// The maximum number of validators to have per core.
///
/// `None` means no maximum.
pub max_validators_per_core: Option<u32>,
/// The maximum number of validators to use for parachain consensus, period.
///
/// `None` means no maximum.
@@ -257,7 +216,7 @@ pub struct HostConfiguration<BlockNumber> {
/// scheduled. This number is controlled by this field.
///
/// This value should be greater than
/// [`paras_availability_period`](Self::paras_availability_period).
/// [`paras_availability_period`](SchedulerParams::paras_availability_period).
pub minimum_validation_upgrade_delay: BlockNumber,
/// The minimum number of valid backing statements required to consider a parachain candidate
/// backable.
@@ -266,6 +225,8 @@ pub struct HostConfiguration<BlockNumber> {
pub node_features: NodeFeatures,
/// Params used by approval-voting
pub approval_voting_params: ApprovalVotingParams,
/// Scheduler parameters
pub scheduler_params: SchedulerParams<BlockNumber>,
}
impl<BlockNumber: Default + From<u32>> Default for HostConfiguration<BlockNumber> {
@@ -275,8 +236,6 @@ impl<BlockNumber: Default + From<u32>> Default for HostConfiguration<BlockNumber
max_candidate_depth: 0,
allowed_ancestry_len: 0,
},
group_rotation_frequency: 1u32.into(),
paras_availability_period: 1u32.into(),
no_show_slots: 1u32.into(),
validation_upgrade_cooldown: Default::default(),
validation_upgrade_delay: 2u32.into(),
@@ -284,10 +243,6 @@ impl<BlockNumber: Default + From<u32>> Default for HostConfiguration<BlockNumber
max_code_size: MAX_CODE_SIZE,
max_pov_size: Default::default(),
max_head_data_size: Default::default(),
coretime_cores: Default::default(),
on_demand_retries: Default::default(),
scheduling_lookahead: 1,
max_validators_per_core: Default::default(),
max_validators: None,
dispute_period: 6,
dispute_post_conclusion_acceptance_period: 100.into(),
@@ -312,13 +267,9 @@ impl<BlockNumber: Default + From<u32>> Default for HostConfiguration<BlockNumber
minimum_validation_upgrade_delay: 2.into(),
executor_params: Default::default(),
approval_voting_params: ApprovalVotingParams { max_approval_coalesce_count: 1 },
on_demand_queue_max_size: ON_DEMAND_DEFAULT_QUEUE_MAX_SIZE,
on_demand_base_fee: 10_000_000u128,
on_demand_fee_variability: Perbill::from_percent(3),
on_demand_target_queue_utilization: Perbill::from_percent(25),
on_demand_ttl: 5u32.into(),
minimum_backing_votes: LEGACY_MIN_BACKING_VOTES,
node_features: NodeFeatures::EMPTY,
scheduler_params: Default::default(),
}
}
}
@@ -359,6 +310,8 @@ pub enum InconsistentError<BlockNumber> {
ZeroMinimumBackingVotes,
/// `executor_params` are inconsistent.
InconsistentExecutorParams { inner: ExecutorParamError },
/// TTL should be bigger than lookahead
LookaheadExceedsTTL,
}
impl<BlockNumber> HostConfiguration<BlockNumber>
@@ -373,11 +326,11 @@ where
pub fn check_consistency(&self) -> Result<(), InconsistentError<BlockNumber>> {
use InconsistentError::*;
if self.group_rotation_frequency.is_zero() {
if self.scheduler_params.group_rotation_frequency.is_zero() {
return Err(ZeroGroupRotationFrequency)
}
if self.paras_availability_period.is_zero() {
if self.scheduler_params.paras_availability_period.is_zero() {
return Err(ZeroParasAvailabilityPeriod)
}
@@ -399,10 +352,11 @@ where
return Err(MaxPovSizeExceedHardLimit { max_pov_size: self.max_pov_size })
}
if self.minimum_validation_upgrade_delay <= self.paras_availability_period {
if self.minimum_validation_upgrade_delay <= self.scheduler_params.paras_availability_period
{
return Err(MinimumValidationUpgradeDelayLessThanChainAvailabilityPeriod {
minimum_validation_upgrade_delay: self.minimum_validation_upgrade_delay.clone(),
paras_availability_period: self.paras_availability_period.clone(),
paras_availability_period: self.scheduler_params.paras_availability_period.clone(),
})
}
@@ -447,6 +401,10 @@ where
return Err(InconsistentExecutorParams { inner })
}
if self.scheduler_params.ttl < self.scheduler_params.lookahead.into() {
return Err(LookaheadExceedsTTL)
}
Ok(())
}
@@ -471,6 +429,7 @@ pub trait WeightInfo {
fn set_config_with_executor_params() -> Weight;
fn set_config_with_perbill() -> Weight;
fn set_node_feature() -> Weight;
fn set_config_with_scheduler_params() -> Weight;
}
pub struct TestWeightInfo;
@@ -499,6 +458,9 @@ impl WeightInfo for TestWeightInfo {
fn set_node_feature() -> Weight {
Weight::MAX
}
fn set_config_with_scheduler_params() -> Weight {
Weight::MAX
}
}
#[frame_support::pallet]
@@ -520,7 +482,8 @@ pub mod pallet {
/// v8-v9: <https://github.com/paritytech/polkadot/pull/7577>
/// v9-v10: <https://github.com/paritytech/polkadot-sdk/pull/2177>
/// v10-11: <https://github.com/paritytech/polkadot-sdk/pull/1191>
const STORAGE_VERSION: StorageVersion = StorageVersion::new(11);
/// v11-12: <https://github.com/paritytech/polkadot-sdk/pull/3181>
const STORAGE_VERSION: StorageVersion = StorageVersion::new(12);
#[pallet::pallet]
#[pallet::storage_version(STORAGE_VERSION)]
@@ -679,16 +642,16 @@ pub mod pallet {
Self::set_coretime_cores_unchecked(new)
}
/// Set the number of retries for a particular on demand.
/// Set the max number of times a claim may timeout on a core before it is abandoned
#[pallet::call_index(7)]
#[pallet::weight((
T::WeightInfo::set_config_with_u32(),
DispatchClass::Operational,
))]
pub fn set_on_demand_retries(origin: OriginFor<T>, new: u32) -> DispatchResult {
pub fn set_max_availability_timeouts(origin: OriginFor<T>, new: u32) -> DispatchResult {
ensure_root(origin)?;
Self::schedule_config_update(|config| {
config.on_demand_retries = new;
config.scheduler_params.max_availability_timeouts = new;
})
}
@@ -704,7 +667,7 @@ pub mod pallet {
) -> DispatchResult {
ensure_root(origin)?;
Self::schedule_config_update(|config| {
config.group_rotation_frequency = new;
config.scheduler_params.group_rotation_frequency = new;
})
}
@@ -720,7 +683,7 @@ pub mod pallet {
) -> DispatchResult {
ensure_root(origin)?;
Self::schedule_config_update(|config| {
config.paras_availability_period = new;
config.scheduler_params.paras_availability_period = new;
})
}
@@ -733,7 +696,7 @@ pub mod pallet {
pub fn set_scheduling_lookahead(origin: OriginFor<T>, new: u32) -> DispatchResult {
ensure_root(origin)?;
Self::schedule_config_update(|config| {
config.scheduling_lookahead = new;
config.scheduler_params.lookahead = new;
})
}
@@ -749,7 +712,7 @@ pub mod pallet {
) -> DispatchResult {
ensure_root(origin)?;
Self::schedule_config_update(|config| {
config.max_validators_per_core = new;
config.scheduler_params.max_validators_per_core = new;
})
}
@@ -1141,7 +1104,7 @@ pub mod pallet {
pub fn set_on_demand_base_fee(origin: OriginFor<T>, new: Balance) -> DispatchResult {
ensure_root(origin)?;
Self::schedule_config_update(|config| {
config.on_demand_base_fee = new;
config.scheduler_params.on_demand_base_fee = new;
})
}
@@ -1154,7 +1117,7 @@ pub mod pallet {
pub fn set_on_demand_fee_variability(origin: OriginFor<T>, new: Perbill) -> DispatchResult {
ensure_root(origin)?;
Self::schedule_config_update(|config| {
config.on_demand_fee_variability = new;
config.scheduler_params.on_demand_fee_variability = new;
})
}
@@ -1167,7 +1130,7 @@ pub mod pallet {
pub fn set_on_demand_queue_max_size(origin: OriginFor<T>, new: u32) -> DispatchResult {
ensure_root(origin)?;
Self::schedule_config_update(|config| {
config.on_demand_queue_max_size = new;
config.scheduler_params.on_demand_queue_max_size = new;
})
}
/// Set the on demand (parathreads) fee variability.
@@ -1182,7 +1145,7 @@ pub mod pallet {
) -> DispatchResult {
ensure_root(origin)?;
Self::schedule_config_update(|config| {
config.on_demand_target_queue_utilization = new;
config.scheduler_params.on_demand_target_queue_utilization = new;
})
}
/// Set the on demand (parathreads) ttl in the claimqueue.
@@ -1194,7 +1157,7 @@ pub mod pallet {
pub fn set_on_demand_ttl(origin: OriginFor<T>, new: BlockNumberFor<T>) -> DispatchResult {
ensure_root(origin)?;
Self::schedule_config_update(|config| {
config.on_demand_ttl = new;
config.scheduler_params.ttl = new;
})
}
@@ -1244,6 +1207,22 @@ pub mod pallet {
config.approval_voting_params = new;
})
}
/// Set scheduler-params.
#[pallet::call_index(55)]
#[pallet::weight((
T::WeightInfo::set_config_with_scheduler_params(),
DispatchClass::Operational,
))]
pub fn set_scheduler_params(
origin: OriginFor<T>,
new: SchedulerParams<BlockNumberFor<T>>,
) -> DispatchResult {
ensure_root(origin)?;
Self::schedule_config_update(|config| {
config.scheduler_params = new;
})
}
}
impl<T: Config> Pallet<T> {
@@ -1252,7 +1231,7 @@ pub mod pallet {
/// To be used if authorization is checked otherwise.
pub fn set_coretime_cores_unchecked(new: u32) -> DispatchResult {
Self::schedule_config_update(|config| {
config.coretime_cores = new;
config.scheduler_params.num_cores = new;
})
}
}
@@ -1393,7 +1372,7 @@ impl<T: Config> Pallet<T> {
let base_config_consistent = base_config.check_consistency().is_ok();
// Now, we need to decide what the new configuration should be.
// We also move the `base_config` to `new_config` to empahsize that the base config was
// We also move the `base_config` to `new_config` to emphasize that the base config was
// destroyed by the `updater`.
updater(&mut base_config);
let new_config = base_config;
polkadot/runtime/parachains/src/configuration/benchmarking.rs
+2
View File
@@ -51,6 +51,8 @@ benchmarks! {
set_node_feature{}: set_node_feature(RawOrigin::Root, 255, true)
set_config_with_scheduler_params {} : set_scheduler_params(RawOrigin::Root, SchedulerParams::default())
impl_benchmark_test_suite!(
Pallet,
crate::mock::new_test_ext(Default::default()),
polkadot/runtime/parachains/src/configuration/migration.rs
+1
View File
@@ -18,6 +18,7 @@
pub mod v10;
pub mod v11;
pub mod v12;
pub mod v6;
pub mod v7;
pub mod v8;
polkadot/runtime/parachains/src/configuration/migration/v11.rs
+111 -2
View File
@@ -21,13 +21,122 @@ use frame_support::{
migrations::VersionedMigration, pallet_prelude::*, traits::Defensive, weights::Weight,
};
use frame_system::pallet_prelude::BlockNumberFor;
use primitives::{vstaging::ApprovalVotingParams, SessionIndex};
use primitives::{
vstaging::ApprovalVotingParams, AsyncBackingParams, ExecutorParams, SessionIndex,
LEGACY_MIN_BACKING_VOTES, ON_DEMAND_DEFAULT_QUEUE_MAX_SIZE,
};
use sp_std::vec::Vec;
use frame_support::traits::OnRuntimeUpgrade;
use polkadot_core_primitives::Balance;
use primitives::vstaging::NodeFeatures;
use sp_arithmetic::Perbill;
use super::v10::V10HostConfiguration;
type V11HostConfiguration<BlockNumber> = configuration::HostConfiguration<BlockNumber>;
#[derive(Clone, Encode, PartialEq, Decode, Debug)]
pub struct V11HostConfiguration<BlockNumber> {
pub max_code_size: u32,
pub max_head_data_size: u32,
pub max_upward_queue_count: u32,
pub max_upward_queue_size: u32,
pub max_upward_message_size: u32,
pub max_upward_message_num_per_candidate: u32,
pub hrmp_max_message_num_per_candidate: u32,
pub validation_upgrade_cooldown: BlockNumber,
pub validation_upgrade_delay: BlockNumber,
pub async_backing_params: AsyncBackingParams,
pub max_pov_size: u32,
pub max_downward_message_size: u32,
pub hrmp_max_parachain_outbound_channels: u32,
pub hrmp_sender_deposit: Balance,
pub hrmp_recipient_deposit: Balance,
pub hrmp_channel_max_capacity: u32,
pub hrmp_channel_max_total_size: u32,
pub hrmp_max_parachain_inbound_channels: u32,
pub hrmp_channel_max_message_size: u32,
pub executor_params: ExecutorParams,
pub code_retention_period: BlockNumber,
pub coretime_cores: u32,
pub on_demand_retries: u32,
pub on_demand_queue_max_size: u32,
pub on_demand_target_queue_utilization: Perbill,
pub on_demand_fee_variability: Perbill,
pub on_demand_base_fee: Balance,
pub on_demand_ttl: BlockNumber,
pub group_rotation_frequency: BlockNumber,
pub paras_availability_period: BlockNumber,
pub scheduling_lookahead: u32,
pub max_validators_per_core: Option<u32>,
pub max_validators: Option<u32>,
pub dispute_period: SessionIndex,
pub dispute_post_conclusion_acceptance_period: BlockNumber,
pub no_show_slots: u32,
pub n_delay_tranches: u32,
pub zeroth_delay_tranche_width: u32,
pub needed_approvals: u32,
pub relay_vrf_modulo_samples: u32,
pub pvf_voting_ttl: SessionIndex,
pub minimum_validation_upgrade_delay: BlockNumber,
pub minimum_backing_votes: u32,
pub node_features: NodeFeatures,
pub approval_voting_params: ApprovalVotingParams,
}
impl<BlockNumber: Default + From<u32>> Default for V11HostConfiguration<BlockNumber> {
fn default() -> Self {
Self {
async_backing_params: AsyncBackingParams {
max_candidate_depth: 0,
allowed_ancestry_len: 0,
},
group_rotation_frequency: 1u32.into(),
paras_availability_period: 1u32.into(),
no_show_slots: 1u32.into(),
validation_upgrade_cooldown: Default::default(),
validation_upgrade_delay: 2u32.into(),
code_retention_period: Default::default(),
max_code_size: Default::default(),
max_pov_size: Default::default(),
max_head_data_size: Default::default(),
coretime_cores: Default::default(),
on_demand_retries: Default::default(),
scheduling_lookahead: 1,
max_validators_per_core: Default::default(),
max_validators: None,
dispute_period: 6,
dispute_post_conclusion_acceptance_period: 100.into(),
n_delay_tranches: Default::default(),
zeroth_delay_tranche_width: Default::default(),
needed_approvals: Default::default(),
relay_vrf_modulo_samples: Default::default(),
max_upward_queue_count: Default::default(),
max_upward_queue_size: Default::default(),
max_downward_message_size: Default::default(),
max_upward_message_size: Default::default(),
max_upward_message_num_per_candidate: Default::default(),
hrmp_sender_deposit: Default::default(),
hrmp_recipient_deposit: Default::default(),
hrmp_channel_max_capacity: Default::default(),
hrmp_channel_max_total_size: Default::default(),
hrmp_max_parachain_inbound_channels: Default::default(),
hrmp_channel_max_message_size: Default::default(),
hrmp_max_parachain_outbound_channels: Default::default(),
hrmp_max_message_num_per_candidate: Default::default(),
pvf_voting_ttl: 2u32.into(),
minimum_validation_upgrade_delay: 2.into(),
executor_params: Default::default(),
approval_voting_params: ApprovalVotingParams { max_approval_coalesce_count: 1 },
on_demand_queue_max_size: ON_DEMAND_DEFAULT_QUEUE_MAX_SIZE,
on_demand_base_fee: 10_000_000u128,
on_demand_fee_variability: Perbill::from_percent(3),
on_demand_target_queue_utilization: Perbill::from_percent(25),
on_demand_ttl: 5u32.into(),
minimum_backing_votes: LEGACY_MIN_BACKING_VOTES,
node_features: NodeFeatures::EMPTY,
}
}
}
mod v10 {
use super::*;
polkadot/runtime/parachains/src/configuration/migration/v12.rs
+349
View File
@@ -0,0 +1,349 @@
// Copyright (C) Parity Technologies (UK) Ltd.
// This file is part of Polkadot.
// Polkadot is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// Polkadot is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with Polkadot. If not, see <http://www.gnu.org/licenses/>.
//! A module that is responsible for migration of storage.
use crate::configuration::{self, migration::v11::V11HostConfiguration, Config, Pallet};
use frame_support::{
migrations::VersionedMigration,
pallet_prelude::*,
traits::{Defensive, OnRuntimeUpgrade},
};
use frame_system::pallet_prelude::BlockNumberFor;
use primitives::vstaging::SchedulerParams;
use sp_core::Get;
use sp_staking::SessionIndex;
use sp_std::vec::Vec;
type V12HostConfiguration<BlockNumber> = configuration::HostConfiguration<BlockNumber>;
mod v11 {
use super::*;
#[frame_support::storage_alias]
pub(crate) type ActiveConfig<T: Config> =
StorageValue<Pallet<T>, V11HostConfiguration<BlockNumberFor<T>>, OptionQuery>;
#[frame_support::storage_alias]
pub(crate) type PendingConfigs<T: Config> = StorageValue<
Pallet<T>,
Vec<(SessionIndex, V11HostConfiguration<BlockNumberFor<T>>)>,
OptionQuery,
>;
}
mod v12 {
use super::*;
#[frame_support::storage_alias]
pub(crate) type ActiveConfig<T: Config> =
StorageValue<Pallet<T>, V12HostConfiguration<BlockNumberFor<T>>, OptionQuery>;
#[frame_support::storage_alias]
pub(crate) type PendingConfigs<T: Config> = StorageValue<
Pallet<T>,
Vec<(SessionIndex, V12HostConfiguration<BlockNumberFor<T>>)>,
OptionQuery,
>;
}
pub type MigrateToV12<T> = VersionedMigration<
11,
12,
UncheckedMigrateToV12<T>,
Pallet<T>,
<T as frame_system::Config>::DbWeight,
>;
pub struct UncheckedMigrateToV12<T>(sp_std::marker::PhantomData<T>);
impl<T: Config> OnRuntimeUpgrade for UncheckedMigrateToV12<T> {
#[cfg(feature = "try-runtime")]
fn pre_upgrade() -> Result<Vec<u8>, sp_runtime::TryRuntimeError> {
log::trace!(target: crate::configuration::LOG_TARGET, "Running pre_upgrade() for HostConfiguration MigrateToV12");
Ok(Vec::new())
}
fn on_runtime_upgrade() -> Weight {
log::info!(target: configuration::LOG_TARGET, "HostConfiguration MigrateToV12 started");
let weight_consumed = migrate_to_v12::<T>();
log::info!(target: configuration::LOG_TARGET, "HostConfiguration MigrateToV12 executed successfully");
weight_consumed
}
#[cfg(feature = "try-runtime")]
fn post_upgrade(_state: Vec<u8>) -> Result<(), sp_runtime::TryRuntimeError> {
log::trace!(target: crate::configuration::LOG_TARGET, "Running post_upgrade() for HostConfiguration MigrateToV12");
ensure!(
StorageVersion::get::<Pallet<T>>() >= 12,
"Storage version should be >= 12 after the migration"
);
Ok(())
}
}
fn migrate_to_v12<T: Config>() -> Weight {
// Unusual formatting is justified:
// - make it easier to verify that fields assign what they supposed to assign.
// - this code is transient and will be removed after all migrations are done.
// - this code is important enough to optimize for legibility sacrificing consistency.
#[rustfmt::skip]
let translate =
|pre: V11HostConfiguration<BlockNumberFor<T>>| ->
V12HostConfiguration<BlockNumberFor<T>>
{
V12HostConfiguration {
max_code_size : pre.max_code_size,
max_head_data_size : pre.max_head_data_size,
max_upward_queue_count : pre.max_upward_queue_count,
max_upward_queue_size : pre.max_upward_queue_size,
max_upward_message_size : pre.max_upward_message_size,
max_upward_message_num_per_candidate : pre.max_upward_message_num_per_candidate,
hrmp_max_message_num_per_candidate : pre.hrmp_max_message_num_per_candidate,
validation_upgrade_cooldown : pre.validation_upgrade_cooldown,
validation_upgrade_delay : pre.validation_upgrade_delay,
max_pov_size : pre.max_pov_size,
max_downward_message_size : pre.max_downward_message_size,
hrmp_sender_deposit : pre.hrmp_sender_deposit,
hrmp_recipient_deposit : pre.hrmp_recipient_deposit,
hrmp_channel_max_capacity : pre.hrmp_channel_max_capacity,
hrmp_channel_max_total_size : pre.hrmp_channel_max_total_size,
hrmp_max_parachain_inbound_channels : pre.hrmp_max_parachain_inbound_channels,
hrmp_max_parachain_outbound_channels : pre.hrmp_max_parachain_outbound_channels,
hrmp_channel_max_message_size : pre.hrmp_channel_max_message_size,
code_retention_period : pre.code_retention_period,
max_validators : pre.max_validators,
dispute_period : pre.dispute_period,
dispute_post_conclusion_acceptance_period: pre.dispute_post_conclusion_acceptance_period,
no_show_slots : pre.no_show_slots,
n_delay_tranches : pre.n_delay_tranches,
zeroth_delay_tranche_width : pre.zeroth_delay_tranche_width,
needed_approvals : pre.needed_approvals,
relay_vrf_modulo_samples : pre.relay_vrf_modulo_samples,
pvf_voting_ttl : pre.pvf_voting_ttl,
minimum_validation_upgrade_delay : pre.minimum_validation_upgrade_delay,
async_backing_params : pre.async_backing_params,
executor_params : pre.executor_params,
minimum_backing_votes : pre.minimum_backing_votes,
node_features : pre.node_features,
approval_voting_params : pre.approval_voting_params,
scheduler_params: SchedulerParams {
group_rotation_frequency : pre.group_rotation_frequency,
paras_availability_period : pre.paras_availability_period,
max_validators_per_core : pre.max_validators_per_core,
lookahead : pre.scheduling_lookahead,
num_cores : pre.coretime_cores,
max_availability_timeouts : pre.on_demand_retries,
on_demand_queue_max_size : pre.on_demand_queue_max_size,
on_demand_target_queue_utilization : pre.on_demand_target_queue_utilization,
on_demand_fee_variability : pre.on_demand_fee_variability,
on_demand_base_fee : pre.on_demand_base_fee,
ttl : pre.on_demand_ttl,
}
}
};
let v11 = v11::ActiveConfig::<T>::get()
.defensive_proof("Could not decode old config")
.unwrap_or_default();
let v12 = translate(v11);
v12::ActiveConfig::<T>::set(Some(v12));
// Allowed to be empty.
let pending_v11 = v11::PendingConfigs::<T>::get().unwrap_or_default();
let mut pending_v12 = Vec::new();
for (session, v11) in pending_v11.into_iter() {
let v12 = translate(v11);
pending_v12.push((session, v12));
}
v12::PendingConfigs::<T>::set(Some(pending_v12.clone()));
let num_configs = (pending_v12.len() + 1) as u64;
T::DbWeight::get().reads_writes(num_configs, num_configs)
}
#[cfg(test)]
mod tests {
use primitives::LEGACY_MIN_BACKING_VOTES;
use sp_arithmetic::Perbill;
use super::*;
use crate::mock::{new_test_ext, Test};
#[test]
fn v12_deserialized_from_actual_data() {
// Example how to get new `raw_config`:
// We'll obtain the raw_config at a specified a block
// Steps:
// 1. Go to Polkadot.js -> Developer -> Chain state -> Storage: https://polkadot.js.org/apps/#/chainstate
// 2. Set these parameters:
// 2.1. selected state query: configuration; activeConfig():
// PolkadotRuntimeParachainsConfigurationHostConfiguration
// 2.2. blockhash to query at:
// 0xf89d3ab5312c5f70d396dc59612f0aa65806c798346f9db4b35278baed2e0e53 (the hash of
// the block)
// 2.3. Note the value of encoded storage key ->
// 0x06de3d8a54d27e44a9d5ce189618f22db4b49d95320d9021994c850f25b8e385 for the
// referenced block.
// 2.4. You'll also need the decoded values to update the test.
// 3. Go to Polkadot.js -> Developer -> Chain state -> Raw storage
// 3.1 Enter the encoded storage key and you get the raw config.
// This exceeds the maximal line width length, but that's fine, since this is not code and
// doesn't need to be read and also leaving it as one line allows to easily copy it.
let raw_config =
hex_literal::hex![
"0000300000800000080000000000100000c8000005000000050000000200000002000000000000000000000000005000000010000400000000000000000000000000000000000000000000000000000000000000000000000800000000200000040000000000100000b004000000060000006400000002000000190000000000000002000000020000000200000005000000020000000001000000140000000400000001010000000100000001000000000000001027000080b2e60e80c3c9018096980000000000000000000000000005000000"
];
let v12 =
V12HostConfiguration::<primitives::BlockNumber>::decode(&mut &raw_config[..]).unwrap();
// We check only a sample of the values here. If we missed any fields or messed up data
// types that would skew all the fields coming after.
assert_eq!(v12.max_code_size, 3_145_728);
assert_eq!(v12.validation_upgrade_cooldown, 2);
assert_eq!(v12.max_pov_size, 5_242_880);
assert_eq!(v12.hrmp_channel_max_message_size, 1_048_576);
assert_eq!(v12.n_delay_tranches, 25);
assert_eq!(v12.minimum_validation_upgrade_delay, 5);
assert_eq!(v12.minimum_backing_votes, LEGACY_MIN_BACKING_VOTES);
assert_eq!(v12.approval_voting_params.max_approval_coalesce_count, 1);
assert_eq!(v12.scheduler_params.group_rotation_frequency, 20);
assert_eq!(v12.scheduler_params.paras_availability_period, 4);
assert_eq!(v12.scheduler_params.lookahead, 1);
assert_eq!(v12.scheduler_params.num_cores, 1);
assert_eq!(v12.scheduler_params.max_availability_timeouts, 0);
assert_eq!(v12.scheduler_params.on_demand_queue_max_size, 10_000);
assert_eq!(
v12.scheduler_params.on_demand_target_queue_utilization,
Perbill::from_percent(25)
);
assert_eq!(v12.scheduler_params.on_demand_fee_variability, Perbill::from_percent(3));
assert_eq!(v12.scheduler_params.on_demand_base_fee, 10_000_000);
assert_eq!(v12.scheduler_params.ttl, 5);
}
#[test]
fn test_migrate_to_v12() {
// Host configuration has lots of fields. However, in this migration we only add one
// field. The most important part to check are a couple of the last fields. We also pick
// extra fields to check arbitrarily, e.g. depending on their position (i.e. the middle) and
// also their type.
//
// We specify only the picked fields and the rest should be provided by the `Default`
// implementation. That implementation is copied over between the two types and should work
// fine.
let v11 = V11HostConfiguration::<primitives::BlockNumber> {
needed_approvals: 69,
paras_availability_period: 55,
hrmp_recipient_deposit: 1337,
max_pov_size: 1111,
minimum_validation_upgrade_delay: 20,
on_demand_ttl: 3,
on_demand_retries: 10,
..Default::default()
};
let mut pending_configs = Vec::new();
pending_configs.push((100, v11.clone()));
pending_configs.push((300, v11.clone()));
new_test_ext(Default::default()).execute_with(|| {
// Implant the v10 version in the state.
v11::ActiveConfig::<Test>::set(Some(v11.clone()));
v11::PendingConfigs::<Test>::set(Some(pending_configs));
migrate_to_v12::<Test>();
let v12 = v12::ActiveConfig::<Test>::get().unwrap();
assert_eq!(v12.approval_voting_params.max_approval_coalesce_count, 1);
let mut configs_to_check = v12::PendingConfigs::<Test>::get().unwrap();
configs_to_check.push((0, v12.clone()));
for (_, v12) in configs_to_check {
#[rustfmt::skip]
{
assert_eq!(v11.max_code_size , v12.max_code_size);
assert_eq!(v11.max_head_data_size , v12.max_head_data_size);
assert_eq!(v11.max_upward_queue_count , v12.max_upward_queue_count);
assert_eq!(v11.max_upward_queue_size , v12.max_upward_queue_size);
assert_eq!(v11.max_upward_message_size , v12.max_upward_message_size);
assert_eq!(v11.max_upward_message_num_per_candidate , v12.max_upward_message_num_per_candidate);
assert_eq!(v11.hrmp_max_message_num_per_candidate , v12.hrmp_max_message_num_per_candidate);
assert_eq!(v11.validation_upgrade_cooldown , v12.validation_upgrade_cooldown);
assert_eq!(v11.validation_upgrade_delay , v12.validation_upgrade_delay);
assert_eq!(v11.max_pov_size , v12.max_pov_size);
assert_eq!(v11.max_downward_message_size , v12.max_downward_message_size);
assert_eq!(v11.hrmp_max_parachain_outbound_channels , v12.hrmp_max_parachain_outbound_channels);
assert_eq!(v11.hrmp_sender_deposit , v12.hrmp_sender_deposit);
assert_eq!(v11.hrmp_recipient_deposit , v12.hrmp_recipient_deposit);
assert_eq!(v11.hrmp_channel_max_capacity , v12.hrmp_channel_max_capacity);
assert_eq!(v11.hrmp_channel_max_total_size , v12.hrmp_channel_max_total_size);
assert_eq!(v11.hrmp_max_parachain_inbound_channels , v12.hrmp_max_parachain_inbound_channels);
assert_eq!(v11.hrmp_channel_max_message_size , v12.hrmp_channel_max_message_size);
assert_eq!(v11.code_retention_period , v12.code_retention_period);
assert_eq!(v11.max_validators , v12.max_validators);
assert_eq!(v11.dispute_period , v12.dispute_period);
assert_eq!(v11.no_show_slots , v12.no_show_slots);
assert_eq!(v11.n_delay_tranches , v12.n_delay_tranches);
assert_eq!(v11.zeroth_delay_tranche_width , v12.zeroth_delay_tranche_width);
assert_eq!(v11.needed_approvals , v12.needed_approvals);
assert_eq!(v11.relay_vrf_modulo_samples , v12.relay_vrf_modulo_samples);
assert_eq!(v11.pvf_voting_ttl , v12.pvf_voting_ttl);
assert_eq!(v11.minimum_validation_upgrade_delay , v12.minimum_validation_upgrade_delay);
assert_eq!(v11.async_backing_params.allowed_ancestry_len, v12.async_backing_params.allowed_ancestry_len);
assert_eq!(v11.async_backing_params.max_candidate_depth , v12.async_backing_params.max_candidate_depth);
assert_eq!(v11.executor_params , v12.executor_params);
assert_eq!(v11.minimum_backing_votes , v12.minimum_backing_votes);
assert_eq!(v11.group_rotation_frequency , v12.scheduler_params.group_rotation_frequency);
assert_eq!(v11.paras_availability_period , v12.scheduler_params.paras_availability_period);
assert_eq!(v11.max_validators_per_core , v12.scheduler_params.max_validators_per_core);
assert_eq!(v11.scheduling_lookahead , v12.scheduler_params.lookahead);
assert_eq!(v11.coretime_cores , v12.scheduler_params.num_cores);
assert_eq!(v11.on_demand_retries , v12.scheduler_params.max_availability_timeouts);
assert_eq!(v11.on_demand_queue_max_size , v12.scheduler_params.on_demand_queue_max_size);
assert_eq!(v11.on_demand_target_queue_utilization , v12.scheduler_params.on_demand_target_queue_utilization);
assert_eq!(v11.on_demand_fee_variability , v12.scheduler_params.on_demand_fee_variability);
assert_eq!(v11.on_demand_base_fee , v12.scheduler_params.on_demand_base_fee);
assert_eq!(v11.on_demand_ttl , v12.scheduler_params.ttl);
}; // ; makes this a statement. `rustfmt::skip` cannot be put on an expression.
}
});
}
// Test that migration doesn't panic in case there are no pending configurations upgrades in
// pallet's storage.
#[test]
fn test_migrate_to_v12_no_pending() {
let v11 = V11HostConfiguration::<primitives::BlockNumber>::default();
new_test_ext(Default::default()).execute_with(|| {
// Implant the v10 version in the state.
v11::ActiveConfig::<Test>::set(Some(v11));
// Ensure there are no pending configs.
v12::PendingConfigs::<Test>::set(None);
// Shouldn't fail.
migrate_to_v12::<Test>();
});
}
}
polkadot/runtime/parachains/src/configuration/tests.rs
+27 -16
View File
@@ -226,8 +226,11 @@ fn invariants() {
);
ActiveConfig::<Test>::put(HostConfiguration {
paras_availability_period: 10,
minimum_validation_upgrade_delay: 11,
scheduler_params: SchedulerParams {
paras_availability_period: 10,
..Default::default()
},
..Default::default()
});
assert_err!(
@@ -283,12 +286,6 @@ fn setting_pending_config_members() {
max_code_size: 100_000,
max_pov_size: 1024,
max_head_data_size: 1_000,
coretime_cores: 2,
on_demand_retries: 5,
group_rotation_frequency: 20,
paras_availability_period: 10,
scheduling_lookahead: 3,
max_validators_per_core: None,
max_validators: None,
dispute_period: 239,
dispute_post_conclusion_acceptance_period: 10,
@@ -314,13 +311,21 @@ fn setting_pending_config_members() {
minimum_validation_upgrade_delay: 20,
executor_params: Default::default(),
approval_voting_params: ApprovalVotingParams { max_approval_coalesce_count: 1 },
minimum_backing_votes: 5,
node_features: bitvec![u8, Lsb0; 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1],
scheduler_params: SchedulerParams {
group_rotation_frequency: 20,
paras_availability_period: 10,
max_validators_per_core: None,
lookahead: 3,
num_cores: 2,
max_availability_timeouts: 5,
on_demand_queue_max_size: 10_000u32,
on_demand_base_fee: 10_000_000u128,
on_demand_fee_variability: Perbill::from_percent(3),
on_demand_target_queue_utilization: Perbill::from_percent(25),
on_demand_ttl: 5u32,
minimum_backing_votes: 5,
node_features: bitvec![u8, Lsb0; 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1],
ttl: 5u32,
},
};
Configuration::set_validation_upgrade_cooldown(
@@ -342,13 +347,19 @@ fn setting_pending_config_members() {
Configuration::set_max_pov_size(RuntimeOrigin::root(), new_config.max_pov_size).unwrap();
Configuration::set_max_head_data_size(RuntimeOrigin::root(), new_config.max_head_data_size)
.unwrap();
Configuration::set_coretime_cores(RuntimeOrigin::root(), new_config.coretime_cores)
Configuration::set_coretime_cores(
RuntimeOrigin::root(),
new_config.scheduler_params.num_cores,
)
.unwrap();
Configuration::set_on_demand_retries(RuntimeOrigin::root(), new_config.on_demand_retries)
Configuration::set_max_availability_timeouts(
RuntimeOrigin::root(),
new_config.scheduler_params.max_availability_timeouts,
)
.unwrap();
Configuration::set_group_rotation_frequency(
RuntimeOrigin::root(),
new_config.group_rotation_frequency,
new_config.scheduler_params.group_rotation_frequency,
)
.unwrap();
// This comes out of order to satisfy the validity criteria for the chain and thread
@@ -360,17 +371,17 @@ fn setting_pending_config_members() {
.unwrap();
Configuration::set_paras_availability_period(
RuntimeOrigin::root(),
new_config.paras_availability_period,
new_config.scheduler_params.paras_availability_period,
)
.unwrap();
Configuration::set_scheduling_lookahead(
RuntimeOrigin::root(),
new_config.scheduling_lookahead,
new_config.scheduler_params.lookahead,
)
.unwrap();
Configuration::set_max_validators_per_core(
RuntimeOrigin::root(),
new_config.max_validators_per_core,
new_config.scheduler_params.max_validators_per_core,
)
.unwrap();
Configuration::set_max_validators(RuntimeOrigin::root(), new_config.max_validators)
polkadot/runtime/parachains/src/coretime/migration.rs
+11 -8
View File
@@ -114,7 +114,7 @@ mod v_coretime {
let legacy_paras = paras::Parachains::<T>::get();
let config = <configuration::Pallet<T>>::config();
let total_core_count = config.coretime_cores + legacy_paras.len() as u32;
let total_core_count = config.scheduler_params.num_cores + legacy_paras.len() as u32;
let dmp_queue_size =
crate::dmp::Pallet::<T>::dmq_contents(T::BrokerId::get().into()).len() as u32;
@@ -150,7 +150,7 @@ mod v_coretime {
// Migrate to Coretime.
//
// NOTE: Also migrates coretime_cores config value in configuration::ActiveConfig.
// NOTE: Also migrates `num_cores` config value in configuration::ActiveConfig.
fn migrate_to_coretime<
T: Config,
SendXcm: xcm::v4::SendXcm,
@@ -176,8 +176,8 @@ mod v_coretime {
}
let config = <configuration::Pallet<T>>::config();
// coretime_cores was on_demand_cores until now:
for on_demand in 0..config.coretime_cores {
// num_cores was on_demand_cores until now:
for on_demand in 0..config.scheduler_params.num_cores {
let core = CoreIndex(legacy_count.saturating_add(on_demand as _));
let r = assigner_coretime::Pallet::<T>::assign_core(
core,
@@ -189,9 +189,9 @@ mod v_coretime {
log::error!("Creating assignment for existing on-demand core, failed: {:?}", err);
}
}
let total_cores = config.coretime_cores + legacy_count;
let total_cores = config.scheduler_params.num_cores + legacy_count;
configuration::ActiveConfig::<T>::mutate(|c| {
c.coretime_cores = total_cores;
c.scheduler_params.num_cores = total_cores;
});
if let Err(err) = migrate_send_assignments_to_coretime_chain::<T, SendXcm, LegacyLease>() {
@@ -200,7 +200,9 @@ mod v_coretime {
let single_weight = <T as Config>::WeightInfo::assign_core(1);
single_weight
.saturating_mul(u64::from(legacy_count.saturating_add(config.coretime_cores)))
.saturating_mul(u64::from(
legacy_count.saturating_add(config.scheduler_params.num_cores),
))
// Second read from sending assignments to the coretime chain.
.saturating_add(T::DbWeight::get().reads_writes(2, 1))
}
@@ -244,7 +246,8 @@ mod v_coretime {
Some(mk_coretime_call(crate::coretime::CoretimeCalls::SetLease(p.into(), time_slice)))
});
let core_count: u16 = configuration::Pallet::<T>::config().coretime_cores.saturated_into();
let core_count: u16 =
configuration::Pallet::<T>::config().scheduler_params.num_cores.saturated_into();
let set_core_count = iter::once(mk_coretime_call(
crate::coretime::CoretimeCalls::NotifyCoreCount(core_count),
));
polkadot/runtime/parachains/src/coretime/mod.rs
+2 -2
View File
@@ -214,8 +214,8 @@ impl<T: Config> Pallet<T> {
}
pub fn initializer_on_new_session(notification: &SessionChangeNotification<BlockNumberFor<T>>) {
let old_core_count = notification.prev_config.coretime_cores;
let new_core_count = notification.new_config.coretime_cores;
let old_core_count = notification.prev_config.scheduler_params.num_cores;
let new_core_count = notification.new_config.scheduler_params.num_cores;
if new_core_count != old_core_count {
let core_count: u16 = new_core_count.saturated_into();
let message = Xcm(vec![
polkadot/runtime/parachains/src/inclusion/tests.rs
+5 -5
View File
@@ -47,10 +47,10 @@ use test_helpers::{dummy_collator, dummy_collator_signature, dummy_validation_co
fn default_config() -> HostConfiguration<BlockNumber> {
let mut config = HostConfiguration::default();
config.coretime_cores = 1;
config.scheduler_params.num_cores = 1;
config.max_code_size = 0b100000;
config.max_head_data_size = 0b100000;
config.group_rotation_frequency = u32::MAX;
config.scheduler_params.group_rotation_frequency = u32::MAX;
config
}
@@ -224,7 +224,7 @@ pub(crate) fn run_to_block(
}
pub(crate) fn expected_bits() -> usize {
Paras::parachains().len() + Configuration::config().coretime_cores as usize
Paras::parachains().len() + Configuration::config().scheduler_params.num_cores as usize
}
fn default_bitfield() -> AvailabilityBitfield {
@@ -386,7 +386,7 @@ fn collect_pending_cleans_up_pending() {
(thread_a, ParaKind::Parathread),
];
let mut config = genesis_config(paras);
config.configuration.config.group_rotation_frequency = 3;
config.configuration.config.scheduler_params.group_rotation_frequency = 3;
new_test_ext(config).execute_with(|| {
let default_candidate = TestCandidateBuilder::default().build();
<PendingAvailability<Test>>::insert(
@@ -2062,7 +2062,7 @@ fn check_allowed_relay_parents() {
}
let validator_public = validator_pubkeys(&validators);
let mut config = genesis_config(paras);
config.configuration.config.group_rotation_frequency = 1;
config.configuration.config.scheduler_params.group_rotation_frequency = 1;
new_test_ext(config).execute_with(|| {
shared::Pallet::<Test>::set_active_validators_ascending(validator_public.clone());
polkadot/runtime/parachains/src/mock.rs
+1 -22
View File
@@ -23,7 +23,7 @@ use crate::{
initializer, origin, paras,
paras::ParaKind,
paras_inherent, scheduler,
scheduler::common::{AssignmentProvider, AssignmentProviderConfig},
scheduler::common::AssignmentProvider,
session_info, shared, ParaId,
};
use frame_support::pallet_prelude::*;
@@ -463,10 +463,6 @@ pub mod mock_assigner {
pub(super) type MockAssignmentQueue<T: Config> =
StorageValue<_, VecDeque<Assignment>, ValueQuery>;
#[pallet::storage]
pub(super) type MockProviderConfig<T: Config> =
StorageValue<_, AssignmentProviderConfig<BlockNumber>, OptionQuery>;
#[pallet::storage]
pub(super) type MockCoreCount<T: Config> = StorageValue<_, u32, OptionQuery>;
}
@@ -478,12 +474,6 @@ pub mod mock_assigner {
MockAssignmentQueue::<T>::mutate(|queue| queue.push_back(assignment));
}
// This configuration needs to be customized to service `get_provider_config` in
// scheduler tests.
pub fn set_assignment_provider_config(config: AssignmentProviderConfig<BlockNumber>) {
MockProviderConfig::<T>::set(Some(config));
}
// Allows for customized core count in scheduler tests, rather than a core count
// derived from on-demand config + parachain count.
pub fn set_core_count(count: u32) {
@@ -512,17 +502,6 @@ pub mod mock_assigner {
// in the mock assigner.
fn push_back_assignment(_assignment: Assignment) {}
// Gets the provider config we set earlier using `set_assignment_provider_config`, falling
// back to the on demand parachain configuration if none was set.
fn get_provider_config(_core_idx: CoreIndex) -> AssignmentProviderConfig<BlockNumber> {
match MockProviderConfig::<T>::get() {
Some(config) => config,
None => AssignmentProviderConfig {
max_availability_timeouts: 1,
ttl: BlockNumber::from(5u32),
},
}
}
#[cfg(any(feature = "runtime-benchmarks", test))]
fn get_mock_assignment(_: CoreIndex, para_id: ParaId) -> Assignment {
Assignment::Bulk(para_id)
polkadot/runtime/parachains/src/paras/tests.rs
+4 -1
View File
@@ -17,7 +17,7 @@
use super::*;
use frame_support::{assert_err, assert_ok, assert_storage_noop};
use keyring::Sr25519Keyring;
use primitives::{BlockNumber, PARACHAIN_KEY_TYPE_ID};
use primitives::{vstaging::SchedulerParams, BlockNumber, PARACHAIN_KEY_TYPE_ID};
use sc_keystore::LocalKeystore;
use sp_keystore::{Keystore, KeystorePtr};
use std::sync::Arc;
@@ -909,9 +909,12 @@ fn full_parachain_cleanup_storage() {
minimum_validation_upgrade_delay: 2,
// Those are not relevant to this test. However, HostConfiguration is still a
// subject for the consistency check.
scheduler_params: SchedulerParams {
paras_availability_period: 1,
..Default::default()
},
..Default::default()
},
},
..Default::default()
};
polkadot/runtime/parachains/src/paras_inherent/tests.rs
+6 -5
View File
@@ -27,13 +27,14 @@ mod enter {
builder::{Bench, BenchBuilder},
mock::{mock_assigner, new_test_ext, BlockLength, BlockWeights, MockGenesisConfig, Test},
scheduler::{
common::{Assignment, AssignmentProvider, AssignmentProviderConfig},
common::{Assignment, AssignmentProvider},
ParasEntry,
},
};
use assert_matches::assert_matches;
use frame_support::assert_ok;
use frame_system::limits;
use primitives::vstaging::SchedulerParams;
use sp_runtime::Perbill;
use sp_std::collections::btree_map::BTreeMap;
@@ -87,7 +88,7 @@ mod enter {
// `create_inherent` and will not cause `enter` to early.
fn include_backed_candidates() {
let config = MockGenesisConfig::default();
assert!(config.configuration.config.scheduling_lookahead > 0);
assert!(config.configuration.config.scheduler_params.lookahead > 0);
new_test_ext(config).execute_with(|| {
let dispute_statements = BTreeMap::new();
@@ -625,7 +626,7 @@ mod enter {
#[test]
fn limit_candidates_over_weight_1() {
let config = MockGenesisConfig::default();
assert!(config.configuration.config.scheduling_lookahead > 0);
assert!(config.configuration.config.scheduler_params.lookahead > 0);
new_test_ext(config).execute_with(|| {
// Create the inherent data for this block
@@ -706,8 +707,8 @@ mod enter {
let cores = (0..used_cores)
.into_iter()
.map(|i| {
let AssignmentProviderConfig { ttl, .. } =
scheduler::Pallet::<Test>::assignment_provider_config(CoreIndex(i));
let SchedulerParams { ttl, .. } =
<configuration::Pallet<Test>>::config().scheduler_params;
// Load an assignment into provider so that one is present to pop
let assignment =
<Test as scheduler::Config>::AssignmentProvider::get_mock_assignment(
polkadot/runtime/parachains/src/scheduler.rs
+16 -25
View File
@@ -51,7 +51,7 @@ use sp_std::{
pub mod common;
use common::{Assignment, AssignmentProvider, AssignmentProviderConfig};
use common::{Assignment, AssignmentProvider};
pub use pallet::*;
@@ -222,7 +222,7 @@ impl<T: Config> Pallet<T> {
let n_cores = core::cmp::max(
T::AssignmentProvider::session_core_count(),
match config.max_validators_per_core {
match config.scheduler_params.max_validators_per_core {
Some(x) if x != 0 => validators.len() as u32 / x,
_ => 0,
},
@@ -350,6 +350,7 @@ impl<T: Config> Pallet<T> {
fn drop_expired_claims_from_claimqueue() {
let now = <frame_system::Pallet<T>>::block_number();
let availability_cores = AvailabilityCores::<T>::get();
let ttl = <configuration::Pallet<T>>::config().scheduler_params.ttl;
ClaimQueue::<T>::mutate(|cq| {
for (idx, _) in (0u32..).zip(availability_cores) {
@@ -382,8 +383,6 @@ impl<T: Config> Pallet<T> {
if let Some(assignment) =
T::AssignmentProvider::pop_assignment_for_core(core_idx)
{
let AssignmentProviderConfig { ttl, .. } =
T::AssignmentProvider::get_provider_config(core_idx);
core_claimqueue.push_back(ParasEntry::new(assignment, now + ttl));
}
}
@@ -428,7 +427,7 @@ impl<T: Config> Pallet<T> {
}
let rotations_since_session_start: BlockNumberFor<T> =
(at - session_start_block) / config.group_rotation_frequency;
(at - session_start_block) / config.scheduler_params.group_rotation_frequency;
let rotations_since_session_start =
<BlockNumberFor<T> as TryInto<u32>>::try_into(rotations_since_session_start)
@@ -460,9 +459,9 @@ impl<T: Config> Pallet<T> {
// Note: blocks backed in this rotation will never time out here as backed_in +
// config.paras_availability_period will always be > now for these blocks, as
// otherwise above condition would not be true.
pending_since + config.paras_availability_period
pending_since + config.scheduler_params.paras_availability_period
} else {
next_rotation + config.paras_availability_period
next_rotation + config.scheduler_params.paras_availability_period
};
AvailabilityTimeoutStatus { timed_out: time_out_at <= now, live_until: time_out_at }
@@ -478,7 +477,8 @@ impl<T: Config> Pallet<T> {
let now = <frame_system::Pallet<T>>::block_number() + One::one();
let rotation_info = Self::group_rotation_info(now);
let current_window = rotation_info.last_rotation_at() + config.paras_availability_period;
let current_window =
rotation_info.last_rotation_at() + config.scheduler_params.paras_availability_period;
now < current_window
}
@@ -488,7 +488,7 @@ impl<T: Config> Pallet<T> {
) -> GroupRotationInfo<BlockNumberFor<T>> {
let session_start_block = Self::session_start_block();
let group_rotation_frequency =
<configuration::Pallet<T>>::config().group_rotation_frequency;
<configuration::Pallet<T>>::config().scheduler_params.group_rotation_frequency;
GroupRotationInfo { session_start_block, now, group_rotation_frequency }
}
@@ -508,6 +508,8 @@ impl<T: Config> Pallet<T> {
/// Return the next thing that will be scheduled on this core assuming it is currently
/// occupied and the candidate occupying it times out.
pub(crate) fn next_up_on_time_out(core: CoreIndex) -> Option<ScheduledCore> {
let max_availability_timeouts =
<configuration::Pallet<T>>::config().scheduler_params.max_availability_timeouts;
Self::next_up_on_available(core).or_else(|| {
// Or, if none, the claim currently occupying the core,
// as it would be put back on the queue after timing out if number of retries is not at
@@ -515,15 +517,11 @@ impl<T: Config> Pallet<T> {
let cores = AvailabilityCores::<T>::get();
cores.get(core.0 as usize).and_then(|c| match c {
CoreOccupied::Free => None,
CoreOccupied::Paras(pe) => {
let AssignmentProviderConfig { max_availability_timeouts, .. } =
T::AssignmentProvider::get_provider_config(core);
CoreOccupied::Paras(pe) =>
if pe.availability_timeouts < max_availability_timeouts {
Some(Self::paras_entry_to_scheduled_core(pe))
} else {
None
}
},
})
})
@@ -566,7 +564,7 @@ impl<T: Config> Pallet<T> {
// ClaimQueue related functions
//
fn claimqueue_lookahead() -> u32 {
<configuration::Pallet<T>>::config().scheduling_lookahead
<configuration::Pallet<T>>::config().scheduler_params.lookahead
}
/// Frees cores and fills the free claimqueue spots by popping from the `AssignmentProvider`.
@@ -585,15 +583,15 @@ impl<T: Config> Pallet<T> {
let n_lookahead = Self::claimqueue_lookahead().max(1);
let n_session_cores = T::AssignmentProvider::session_core_count();
let cq = ClaimQueue::<T>::get();
let ttl = <configuration::Pallet<T>>::config().on_demand_ttl;
let config = <configuration::Pallet<T>>::config();
let max_availability_timeouts = config.scheduler_params.max_availability_timeouts;
let ttl = config.scheduler_params.ttl;
for core_idx in 0..n_session_cores {
let core_idx = CoreIndex::from(core_idx);
// add previously timedout paras back into the queue
if let Some(mut entry) = timedout_paras.remove(&core_idx) {
let AssignmentProviderConfig { max_availability_timeouts, .. } =
T::AssignmentProvider::get_provider_config(core_idx);
if entry.availability_timeouts < max_availability_timeouts {
// Increment the timeout counter.
entry.availability_timeouts += 1;
@@ -668,13 +666,6 @@ impl<T: Config> Pallet<T> {
.filter_map(|(core_idx, v)| v.front().map(|e| (core_idx, e.assignment.para_id())))
}
#[cfg(any(feature = "runtime-benchmarks", test))]
pub(crate) fn assignment_provider_config(
core_idx: CoreIndex,
) -> AssignmentProviderConfig<BlockNumberFor<T>> {
T::AssignmentProvider::get_provider_config(core_idx)
}
#[cfg(any(feature = "try-runtime", test))]
fn claimqueue_len() -> usize {
ClaimQueue::<T>::get().iter().map(|la_vec| la_vec.1.len()).sum()
polkadot/runtime/parachains/src/scheduler/common.rs
+2 -17
View File
@@ -48,22 +48,10 @@ impl Assignment {
}
}
#[derive(Encode, Decode, TypeInfo)]
/// A set of variables required by the scheduler in order to operate.
pub struct AssignmentProviderConfig<BlockNumber> {
/// How many times a collation can time out on availability.
/// Zero timeouts still means that a collation can be provided as per the slot auction
/// assignment provider.
pub max_availability_timeouts: u32,
/// How long the collator has to provide a collation to the backing group before being dropped.
pub ttl: BlockNumber,
}
pub trait AssignmentProvider<BlockNumber> {
/// Pops an [`Assignment`] from the provider for a specified [`CoreIndex`].
///
/// This is where assignments come into existance.
/// This is where assignments come into existence.
fn pop_assignment_for_core(core_idx: CoreIndex) -> Option<Assignment>;
/// A previously popped `Assignment` has been fully processed.
@@ -77,14 +65,11 @@ pub trait AssignmentProvider<BlockNumber> {
/// Push back a previously popped assignment.
///
/// If the assignment could not be processed within the current session, it can be pushed back
/// to the assignment provider in order to be poppped again later.
/// to the assignment provider in order to be popped again later.
///
/// This is the second way the life of an assignment can come to an end.
fn push_back_assignment(assignment: Assignment);
/// Returns a set of variables needed by the scheduler
fn get_provider_config(core_idx: CoreIndex) -> AssignmentProviderConfig<BlockNumber>;
/// Push some assignment for mocking/benchmarks purposes.
///
/// Useful for benchmarks and testing. The returned assignment is "valid" and can if need be
polkadot/runtime/parachains/src/scheduler/tests.rs
+41 -40
View File
@@ -18,7 +18,9 @@ use super::*;
use frame_support::assert_ok;
use keyring::Sr25519Keyring;
use primitives::{BlockNumber, SessionIndex, ValidationCode, ValidatorId};
use primitives::{
vstaging::SchedulerParams, BlockNumber, SessionIndex, ValidationCode, ValidatorId,
};
use sp_std::collections::{btree_map::BTreeMap, btree_set::BTreeSet};
use crate::{
@@ -103,15 +105,19 @@ fn run_to_end_of_block(
fn default_config() -> HostConfiguration<BlockNumber> {
HostConfiguration {
coretime_cores: 3,
group_rotation_frequency: 10,
paras_availability_period: 3,
scheduling_lookahead: 2,
// This field does not affect anything that scheduler does. However, `HostConfiguration`
// is still a subject to consistency test. It requires that
// `minimum_validation_upgrade_delay` is greater than `chain_availability_period` and
// `thread_availability_period`.
minimum_validation_upgrade_delay: 6,
scheduler_params: SchedulerParams {
group_rotation_frequency: 10,
paras_availability_period: 3,
lookahead: 2,
num_cores: 3,
max_availability_timeouts: 1,
..Default::default()
},
..Default::default()
}
}
@@ -155,7 +161,7 @@ fn scheduled_entries() -> impl Iterator<Item = (CoreIndex, ParasEntry<BlockNumbe
#[test]
fn claimqueue_ttl_drop_fn_works() {
let mut config = default_config();
config.scheduling_lookahead = 3;
config.scheduler_params.lookahead = 3;
let genesis_config = genesis_config(&config);
let para_id = ParaId::from(100);
@@ -163,8 +169,7 @@ fn claimqueue_ttl_drop_fn_works() {
let mut now = 10;
new_test_ext(genesis_config).execute_with(|| {
let assignment_provider_ttl = MockAssigner::get_provider_config(CoreIndex::from(0)).ttl;
assert!(assignment_provider_ttl == 5);
assert!(config.scheduler_params.ttl == 5);
// Register and run to a blockheight where the para is in a valid state.
schedule_blank_para(para_id);
run_to_block(now, |n| if n == now { Some(Default::default()) } else { None });
@@ -290,7 +295,7 @@ fn session_change_shuffles_validators() {
fn session_change_takes_only_max_per_core() {
let config = {
let mut config = default_config();
config.max_validators_per_core = Some(1);
config.scheduler_params.max_validators_per_core = Some(1);
config
};
@@ -330,7 +335,8 @@ fn session_change_takes_only_max_per_core() {
#[test]
fn fill_claimqueue_fills() {
let genesis_config = genesis_config(&default_config());
let config = default_config();
let genesis_config = genesis_config(&config);
let para_a = ParaId::from(3_u32);
let para_b = ParaId::from(4_u32);
@@ -342,8 +348,7 @@ fn fill_claimqueue_fills() {
new_test_ext(genesis_config).execute_with(|| {
MockAssigner::set_core_count(2);
let AssignmentProviderConfig { ttl: config_ttl, .. } =
MockAssigner::get_provider_config(CoreIndex(0));
let coretime_ttl = config.scheduler_params.ttl;
// Add 3 paras
schedule_blank_para(para_a);
@@ -381,7 +386,7 @@ fn fill_claimqueue_fills() {
&ParasEntry {
assignment: assignment_a.clone(),
availability_timeouts: 0,
ttl: 2 + config_ttl
ttl: 2 + coretime_ttl
},
);
// Sits on the same core as `para_a`
@@ -390,7 +395,7 @@ fn fill_claimqueue_fills() {
ParasEntry {
assignment: assignment_b.clone(),
availability_timeouts: 0,
ttl: 2 + config_ttl
ttl: 2 + coretime_ttl
}
);
assert_eq!(
@@ -398,7 +403,7 @@ fn fill_claimqueue_fills() {
&ParasEntry {
assignment: assignment_c.clone(),
availability_timeouts: 0,
ttl: 2 + config_ttl
ttl: 2 + coretime_ttl
},
);
}
@@ -410,7 +415,7 @@ fn schedule_schedules_including_just_freed() {
let mut config = default_config();
// NOTE: This test expects on demand cores to each get slotted on to a different core
// and not fill up the claimqueue of each core first.
config.scheduling_lookahead = 1;
config.scheduler_params.lookahead = 1;
let genesis_config = genesis_config(&config);
let para_a = ParaId::from(3_u32);
@@ -479,7 +484,7 @@ fn schedule_schedules_including_just_freed() {
// All `core_queue`s should be empty
Scheduler::claimqueue()
.iter()
.for_each(|(_core_idx, core_queue)| assert!(core_queue.len() == 0))
.for_each(|(_core_idx, core_queue)| assert_eq!(core_queue.len(), 0))
}
// add a couple more para claims - the claim on `b` will go to the 3rd core
@@ -557,7 +562,7 @@ fn schedule_schedules_including_just_freed() {
#[test]
fn schedule_clears_availability_cores() {
let mut config = default_config();
config.scheduling_lookahead = 1;
config.scheduler_params.lookahead = 1;
let genesis_config = genesis_config(&config);
let para_a = ParaId::from(1_u32);
@@ -659,11 +664,11 @@ fn schedule_clears_availability_cores() {
fn schedule_rotates_groups() {
let config = {
let mut config = default_config();
config.scheduling_lookahead = 1;
config.scheduler_params.lookahead = 1;
config
};
let rotation_frequency = config.group_rotation_frequency;
let rotation_frequency = config.scheduler_params.group_rotation_frequency;
let on_demand_cores = 2;
let genesis_config = genesis_config(&config);
@@ -742,9 +747,12 @@ fn schedule_rotates_groups() {
#[test]
fn on_demand_claims_are_pruned_after_timing_out() {
let max_retries = 20;
let max_timeouts = 20;
let mut config = default_config();
config.scheduling_lookahead = 1;
config.scheduler_params.lookahead = 1;
// Need more timeouts for this test
config.scheduler_params.max_availability_timeouts = max_timeouts;
config.scheduler_params.ttl = BlockNumber::from(5u32);
let genesis_config = genesis_config(&config);
let para_a = ParaId::from(1_u32);
@@ -753,11 +761,6 @@ fn on_demand_claims_are_pruned_after_timing_out() {
new_test_ext(genesis_config).execute_with(|| {
MockAssigner::set_core_count(2);
// Need more timeouts for this test
MockAssigner::set_assignment_provider_config(AssignmentProviderConfig {
max_availability_timeouts: max_retries,
ttl: BlockNumber::from(5u32),
});
schedule_blank_para(para_a);
// #1
@@ -794,7 +797,7 @@ fn on_demand_claims_are_pruned_after_timing_out() {
// Run to block #n over the max_retries value.
// In this case, both validator groups with time out on availability and
// the assignment will be dropped.
for n in now..=(now + max_retries + 1) {
for n in now..=(now + max_timeouts + 1) {
// #n
run_to_block(n, |_| None);
// Time out on core 0.
@@ -806,7 +809,7 @@ fn on_demand_claims_are_pruned_after_timing_out() {
Scheduler::free_cores_and_fill_claimqueue(just_updated, now);
// ParaId a exists in the claim queue until max_retries is reached.
if n < max_retries + now {
if n < max_timeouts + now {
assert!(claimqueue_contains_para_ids::<Test>(vec![para_a]));
} else {
assert!(!claimqueue_contains_para_ids::<Test>(vec![para_a]));
@@ -822,7 +825,7 @@ fn on_demand_claims_are_pruned_after_timing_out() {
assert!(!availability_cores_contains_para_ids::<Test>(vec![para_a]));
// #25
now += max_retries + 2;
now += max_timeouts + 2;
// Add assignment back to the mix.
MockAssigner::add_test_assignment(assignment_a.clone());
@@ -833,7 +836,7 @@ fn on_demand_claims_are_pruned_after_timing_out() {
// #26
now += 1;
// Run to block #n but this time have group 1 conclude the availabilty.
for n in now..=(now + max_retries + 1) {
for n in now..=(now + max_timeouts + 1) {
// #n
run_to_block(n, |_| None);
// Time out core 0 if group 0 is assigned to it, if group 1 is assigned, conclude.
@@ -874,10 +877,8 @@ fn on_demand_claims_are_pruned_after_timing_out() {
fn availability_predicate_works() {
let genesis_config = genesis_config(&default_config());
let HostConfiguration { group_rotation_frequency, paras_availability_period, .. } =
default_config();
assert!(paras_availability_period < group_rotation_frequency);
let SchedulerParams { group_rotation_frequency, paras_availability_period, .. } =
default_config().scheduler_params;
new_test_ext(genesis_config).execute_with(|| {
run_to_block(1 + paras_availability_period, |_| None);
@@ -1044,7 +1045,7 @@ fn next_up_on_time_out_reuses_claim_if_nothing_queued() {
#[test]
fn session_change_requires_reschedule_dropping_removed_paras() {
let mut config = default_config();
config.scheduling_lookahead = 1;
config.scheduler_params.lookahead = 1;
let genesis_config = genesis_config(&config);
let para_a = ParaId::from(1_u32);
@@ -1056,7 +1057,7 @@ fn session_change_requires_reschedule_dropping_removed_paras() {
new_test_ext(genesis_config).execute_with(|| {
// Setting explicit core count
MockAssigner::set_core_count(5);
let assignment_provider_ttl = MockAssigner::get_provider_config(CoreIndex::from(0)).ttl;
let coretime_ttl = <configuration::Pallet<Test>>::config().scheduler_params.ttl;
schedule_blank_para(para_a);
schedule_blank_para(para_b);
@@ -1120,7 +1121,7 @@ fn session_change_requires_reschedule_dropping_removed_paras() {
vec![ParasEntry::new(
Assignment::Bulk(para_a),
// At end of block 2
assignment_provider_ttl + 2
coretime_ttl + 2
)]
.into_iter()
.collect()
@@ -1169,7 +1170,7 @@ fn session_change_requires_reschedule_dropping_removed_paras() {
vec![ParasEntry::new(
Assignment::Bulk(para_a),
// At block 3
assignment_provider_ttl + 3
coretime_ttl + 3
)]
.into_iter()
.collect()
@@ -1179,7 +1180,7 @@ fn session_change_requires_reschedule_dropping_removed_paras() {
vec![ParasEntry::new(
Assignment::Bulk(para_b),
// At block 3
assignment_provider_ttl + 3
coretime_ttl + 3
)]
.into_iter()
.collect()
polkadot/runtime/parachains/src/session_info/tests.rs
+2 -2
View File
@@ -25,7 +25,7 @@ use crate::{
util::take_active_subset,
};
use keyring::Sr25519Keyring;
use primitives::{BlockNumber, ValidatorId, ValidatorIndex};
use primitives::{vstaging::SchedulerParams, BlockNumber, ValidatorId, ValidatorIndex};
fn run_to_block(
to: BlockNumber,
@@ -62,9 +62,9 @@ fn run_to_block(
fn default_config() -> HostConfiguration<BlockNumber> {
HostConfiguration {
coretime_cores: 1,
dispute_period: 2,
needed_approvals: 3,
scheduler_params: SchedulerParams { num_cores: 1, ..Default::default() },
..Default::default()
}
}
polkadot/runtime/rococo/src/lib.rs
+1
View File
@@ -1658,6 +1658,7 @@ pub mod migrations {
parachains_configuration::migration::v11::MigrateToV11<Runtime>,
// This needs to come after the `parachains_configuration` above as we are reading the configuration.
coretime::migration::MigrateToCoretime<Runtime, crate::xcm_config::XcmRouter, GetLegacyLeaseImpl>,
parachains_configuration::migration::v12::MigrateToV12<Runtime>,
// permanent
pallet_xcm::migration::MigrateToLatestXcmVersion<Runtime>,
polkadot/runtime/rococo/src/weights/runtime_parachains_configuration.rs
+33 -17
View File
@@ -16,10 +16,10 @@
//! Autogenerated weights for `runtime_parachains::configuration`
//!
//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
//! DATE: 2023-11-10, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0
//! DATE: 2024-02-08, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
//! WORST CASE MAP SIZE: `1000000`
//! HOSTNAME: `runner-yprdrvc7-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
//! HOSTNAME: `runner-bn-ce5rx-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("rococo-dev")`, DB CACHE: 1024
// Executed Command:
@@ -58,8 +58,8 @@ impl<T: frame_system::Config> runtime_parachains::configuration::WeightInfo for
// Proof Size summary in bytes:
// Measured: `151`
// Estimated: `1636`
// Minimum execution time: 7_793_000 picoseconds.
Weight::from_parts(8_192_000, 0)
// Minimum execution time: 7_789_000 picoseconds.
Weight::from_parts(8_269_000, 0)
.saturating_add(Weight::from_parts(0, 1636))
.saturating_add(T::DbWeight::get().reads(3))
.saturating_add(T::DbWeight::get().writes(1))
@@ -74,8 +74,8 @@ impl<T: frame_system::Config> runtime_parachains::configuration::WeightInfo for
// Proof Size summary in bytes:
// Measured: `151`
// Estimated: `1636`
// Minimum execution time: 7_819_000 picoseconds.
Weight::from_parts(8_004_000, 0)
// Minimum execution time: 7_851_000 picoseconds.
Weight::from_parts(8_152_000, 0)
.saturating_add(Weight::from_parts(0, 1636))
.saturating_add(T::DbWeight::get().reads(3))
.saturating_add(T::DbWeight::get().writes(1))
@@ -90,8 +90,8 @@ impl<T: frame_system::Config> runtime_parachains::configuration::WeightInfo for
// Proof Size summary in bytes:
// Measured: `151`
// Estimated: `1636`
// Minimum execution time: 7_760_000 picoseconds.
Weight::from_parts(8_174_000, 0)
// Minimum execution time: 7_960_000 picoseconds.
Weight::from_parts(8_276_000, 0)
.saturating_add(Weight::from_parts(0, 1636))
.saturating_add(T::DbWeight::get().reads(3))
.saturating_add(T::DbWeight::get().writes(1))
@@ -116,8 +116,8 @@ impl<T: frame_system::Config> runtime_parachains::configuration::WeightInfo for
// Proof Size summary in bytes:
// Measured: `151`
// Estimated: `1636`
// Minimum execution time: 7_814_000 picoseconds.
Weight::from_parts(8_098_000, 0)
// Minimum execution time: 7_912_000 picoseconds.
Weight::from_parts(8_164_000, 0)
.saturating_add(Weight::from_parts(0, 1636))
.saturating_add(T::DbWeight::get().reads(3))
.saturating_add(T::DbWeight::get().writes(1))
@@ -132,8 +132,8 @@ impl<T: frame_system::Config> runtime_parachains::configuration::WeightInfo for
// Proof Size summary in bytes:
// Measured: `151`
// Estimated: `1636`
// Minimum execution time: 10_028_000 picoseconds.
Weight::from_parts(10_386_000, 0)
// Minimum execution time: 9_782_000 picoseconds.
Weight::from_parts(10_373_000, 0)
.saturating_add(Weight::from_parts(0, 1636))
.saturating_add(T::DbWeight::get().reads(3))
.saturating_add(T::DbWeight::get().writes(1))
@@ -148,8 +148,8 @@ impl<T: frame_system::Config> runtime_parachains::configuration::WeightInfo for
// Proof Size summary in bytes:
// Measured: `151`
// Estimated: `1636`
// Minimum execution time: 7_867_000 picoseconds.
Weight::from_parts(8_191_000, 0)
// Minimum execution time: 7_870_000 picoseconds.
Weight::from_parts(8_274_000, 0)
.saturating_add(Weight::from_parts(0, 1636))
.saturating_add(T::DbWeight::get().reads(3))
.saturating_add(T::DbWeight::get().writes(1))
@@ -164,8 +164,24 @@ impl<T: frame_system::Config> runtime_parachains::configuration::WeightInfo for
// Proof Size summary in bytes:
// Measured: `151`
// Estimated: `1636`
// Minimum execution time: 10_158_000 picoseconds.
Weight::from_parts(10_430_000, 0)
// Minimum execution time: 9_960_000 picoseconds.
Weight::from_parts(10_514_000, 0)
.saturating_add(Weight::from_parts(0, 1636))
.saturating_add(T::DbWeight::get().reads(3))
.saturating_add(T::DbWeight::get().writes(1))
}
/// Storage: `Configuration::PendingConfigs` (r:1 w:1)
/// Proof: `Configuration::PendingConfigs` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
/// Storage: `Configuration::BypassConsistencyCheck` (r:1 w:0)
/// Proof: `Configuration::BypassConsistencyCheck` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
/// Storage: `ParasShared::CurrentSessionIndex` (r:1 w:0)
/// Proof: `ParasShared::CurrentSessionIndex` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
fn set_config_with_scheduler_params() -> Weight {
// Proof Size summary in bytes:
// Measured: `151`
// Estimated: `1636`
// Minimum execution time: 7_913_000 picoseconds.
Weight::from_parts(8_338_000, 0)
.saturating_add(Weight::from_parts(0, 1636))
.saturating_add(T::DbWeight::get().reads(3))
.saturating_add(T::DbWeight::get().writes(1))
polkadot/runtime/westend/src/lib.rs
+1
View File
@@ -1699,6 +1699,7 @@ pub mod migrations {
// Migrate Identity pallet for Usernames
pallet_identity::migration::versioned::V0ToV1<Runtime, IDENTITY_MIGRATION_KEY_LIMIT>,
parachains_configuration::migration::v11::MigrateToV11<Runtime>,
parachains_configuration::migration::v12::MigrateToV12<Runtime>,
// permanent
pallet_xcm::migration::MigrateToLatestXcmVersion<Runtime>,
// Migrate from legacy lease to coretime. Needs to run after configuration v11
polkadot/runtime/westend/src/weights/runtime_parachains_configuration.rs
+33 -17
View File
@@ -16,10 +16,10 @@
//! Autogenerated weights for `runtime_parachains::configuration`
//!
//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
//! DATE: 2023-11-10, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0
//! DATE: 2024-02-08, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
//! WORST CASE MAP SIZE: `1000000`
//! HOSTNAME: `runner-yprdrvc7-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
//! HOSTNAME: `runner-bn-ce5rx-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("westend-dev")`, DB CACHE: 1024
// Executed Command:
@@ -58,8 +58,8 @@ impl<T: frame_system::Config> runtime_parachains::configuration::WeightInfo for
// Proof Size summary in bytes:
// Measured: `151`
// Estimated: `1636`
// Minimum execution time: 8_065_000 picoseconds.
Weight::from_parts(8_389_000, 0)
// Minimum execution time: 7_775_000 picoseconds.
Weight::from_parts(8_036_000, 0)
.saturating_add(Weight::from_parts(0, 1636))
.saturating_add(T::DbWeight::get().reads(3))
.saturating_add(T::DbWeight::get().writes(1))
@@ -74,8 +74,8 @@ impl<T: frame_system::Config> runtime_parachains::configuration::WeightInfo for
// Proof Size summary in bytes:
// Measured: `151`
// Estimated: `1636`
// Minimum execution time: 8_038_000 picoseconds.
Weight::from_parts(8_463_000, 0)
// Minimum execution time: 7_708_000 picoseconds.
Weight::from_parts(7_971_000, 0)
.saturating_add(Weight::from_parts(0, 1636))
.saturating_add(T::DbWeight::get().reads(3))
.saturating_add(T::DbWeight::get().writes(1))
@@ -90,8 +90,8 @@ impl<T: frame_system::Config> runtime_parachains::configuration::WeightInfo for
// Proof Size summary in bytes:
// Measured: `151`
// Estimated: `1636`
// Minimum execution time: 7_843_000 picoseconds.
Weight::from_parts(8_216_000, 0)
// Minimum execution time: 7_746_000 picoseconds.
Weight::from_parts(8_028_000, 0)
.saturating_add(Weight::from_parts(0, 1636))
.saturating_add(T::DbWeight::get().reads(3))
.saturating_add(T::DbWeight::get().writes(1))
@@ -116,8 +116,8 @@ impl<T: frame_system::Config> runtime_parachains::configuration::WeightInfo for
// Proof Size summary in bytes:
// Measured: `151`
// Estimated: `1636`
// Minimum execution time: 7_969_000 picoseconds.
Weight::from_parts(8_362_000, 0)
// Minimum execution time: 7_729_000 picoseconds.
Weight::from_parts(7_954_000, 0)
.saturating_add(Weight::from_parts(0, 1636))
.saturating_add(T::DbWeight::get().reads(3))
.saturating_add(T::DbWeight::get().writes(1))
@@ -132,8 +132,8 @@ impl<T: frame_system::Config> runtime_parachains::configuration::WeightInfo for
// Proof Size summary in bytes:
// Measured: `151`
// Estimated: `1636`
// Minimum execution time: 10_084_000 picoseconds.
Weight::from_parts(10_451_000, 0)
// Minimum execution time: 9_871_000 picoseconds.
Weight::from_parts(10_075_000, 0)
.saturating_add(Weight::from_parts(0, 1636))
.saturating_add(T::DbWeight::get().reads(3))
.saturating_add(T::DbWeight::get().writes(1))
@@ -148,8 +148,8 @@ impl<T: frame_system::Config> runtime_parachains::configuration::WeightInfo for
// Proof Size summary in bytes:
// Measured: `151`
// Estimated: `1636`
// Minimum execution time: 7_948_000 picoseconds.
Weight::from_parts(8_268_000, 0)
// Minimum execution time: 7_869_000 picoseconds.
Weight::from_parts(8_000_000, 0)
.saturating_add(Weight::from_parts(0, 1636))
.saturating_add(T::DbWeight::get().reads(3))
.saturating_add(T::DbWeight::get().writes(1))
@@ -164,8 +164,24 @@ impl<T: frame_system::Config> runtime_parachains::configuration::WeightInfo for
// Proof Size summary in bytes:
// Measured: `151`
// Estimated: `1636`
// Minimum execution time: 10_257_000 picoseconds.
Weight::from_parts(10_584_000, 0)
// Minimum execution time: 9_797_000 picoseconds.
Weight::from_parts(10_373_000, 0)
.saturating_add(Weight::from_parts(0, 1636))
.saturating_add(T::DbWeight::get().reads(3))
.saturating_add(T::DbWeight::get().writes(1))
}
/// Storage: `Configuration::PendingConfigs` (r:1 w:1)
/// Proof: `Configuration::PendingConfigs` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
/// Storage: `Configuration::BypassConsistencyCheck` (r:1 w:0)
/// Proof: `Configuration::BypassConsistencyCheck` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
/// Storage: `ParasShared::CurrentSessionIndex` (r:1 w:0)
/// Proof: `ParasShared::CurrentSessionIndex` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
fn set_config_with_scheduler_params() -> Weight {
// Proof Size summary in bytes:
// Measured: `151`
// Estimated: `1636`
// Minimum execution time: 7_718_000 picoseconds.
Weight::from_parts(7_984_000, 0)
.saturating_add(Weight::from_parts(0, 1636))
.saturating_add(T::DbWeight::get().reads(3))
.saturating_add(T::DbWeight::get().writes(1))
polkadot/zombienet_tests/functional/0002-parachains-disputes.toml
+3 -1
View File
@@ -2,9 +2,11 @@
timeout = 1000
[relaychain.genesis.runtimeGenesis.patch.configuration.config]
max_validators_per_core = 5
needed_approvals = 8
[relaychain.genesis.runtimeGenesis.patch.configuration.config.scheduler_params]
max_validators_per_core = 5
[relaychain.genesis.runtimeGenesis.patch.configuration.config.approval_voting_params]
max_approval_coalesce_count = 5
polkadot/zombienet_tests/functional/0004-parachains-garbage-candidate.toml
+3 -1
View File
@@ -2,8 +2,10 @@
timeout = 1000
bootnode = true
[relaychain.genesis.runtimeGenesis.patch.configuration.config]
[relaychain.genesis.runtimeGenesis.patch.configuration.config.scheduler_params]
max_validators_per_core = 1
[relaychain.genesis.runtimeGenesis.patch.configuration.config]
needed_approvals = 2
[relaychain]
polkadot/zombienet_tests/functional/0005-parachains-disputes-past-session.toml
+3 -1
View File
@@ -3,8 +3,10 @@ timeout = 1000
bootnode = true
[relaychain.genesis.runtimeGenesis.patch.configuration.config]
max_validators_per_core = 1
needed_approvals = 2
[relaychain.genesis.runtimeGenesis.patch.configuration.config.scheduler_params]
max_validators_per_core = 1
group_rotation_frequency = 2
[relaychain]
polkadot/zombienet_tests/functional/0006-parachains-max-tranche0.toml
+3 -1
View File
@@ -3,10 +3,12 @@ timeout = 1000
bootnode = true
[relaychain.genesis.runtimeGenesis.patch.configuration.config]
max_validators_per_core = 1
needed_approvals = 7
relay_vrf_modulo_samples = 5
[relaychain.genesis.runtimeGenesis.patch.configuration.config.scheduler_params]
max_validators_per_core = 1
[relaychain]
default_image = "{{ZOMBIENET_INTEGRATION_TEST_IMAGE}}"
chain = "rococo-local"
polkadot/zombienet_tests/functional/0007-dispute-freshly-finalized.toml
+3 -1
View File
@@ -2,9 +2,11 @@
timeout = 1000
[relaychain.genesis.runtimeGenesis.patch.configuration.config]
max_validators_per_core = 1
needed_approvals = 1
[relaychain.genesis.runtimeGenesis.patch.configuration.config.scheduler_params]
max_validators_per_core = 1
[relaychain]
default_image = "{{ZOMBIENET_INTEGRATION_TEST_IMAGE}}"
chain = "rococo-local"
polkadot/zombienet_tests/functional/0008-dispute-old-finalized.toml
+3 -1
View File
@@ -2,9 +2,11 @@
timeout = 1000
[relaychain.genesis.runtimeGenesis.patch.configuration.config]
max_validators_per_core = 1
needed_approvals = 1
[relaychain.genesis.runtimeGenesis.patch.configuration.config.scheduler_params]
max_validators_per_core = 1
[relaychain]
default_image = "{{ZOMBIENET_INTEGRATION_TEST_IMAGE}}"
chain = "rococo-local"
polkadot/zombienet_tests/functional/0010-validator-disabling.toml
+3 -1
View File
@@ -3,8 +3,10 @@ timeout = 1000
bootnode = true
[relaychain.genesis.runtimeGenesis.patch.configuration.config]
max_validators_per_core = 1
needed_approvals = 2
[relaychain.genesis.runtimeGenesis.patch.configuration.config.scheduler_params]
max_validators_per_core = 1
group_rotation_frequency = 10
[relaychain]
polkadot/zombienet_tests/functional/0011-async-backing-6-seconds-rate.toml
+5 -2
View File
@@ -8,13 +8,16 @@ chain = "rococo-local"
[relaychain.genesis.runtimeGenesis.patch.configuration.config]
needed_approvals = 4
relay_vrf_modulo_samples = 6
scheduling_lookahead = 2
group_rotation_frequency = 4
[relaychain.genesis.runtimeGenesis.patch.configuration.config.async_backing_params]
max_candidate_depth = 3
allowed_ancestry_len = 2
[relaychain.genesis.runtimeGenesis.patch.configuration.config.scheduler_params]
lookahead = 2
group_rotation_frequency = 4
[relaychain.default_resources]
limits = { memory = "4G", cpu = "2" }
requests = { memory = "2G", cpu = "1" }
polkadot/zombienet_tests/functional/0012-elastic-scaling-mvp.toml
+4 -2
View File
@@ -3,9 +3,11 @@ timeout = 1000
bootnode = true
[relaychain.genesis.runtimeGenesis.patch.configuration.config]
max_validators_per_core = 2
needed_approvals = 4
coretime_cores = 2
[relaychain.genesis.runtimeGenesis.patch.configuration.config.scheduler_params]
max_validators_per_core = 2
num_cores = 2
[relaychain]
default_image = "{{ZOMBIENET_INTEGRATION_TEST_IMAGE}}"
polkadot/zombienet_tests/misc/0001-paritydb.toml
+3 -1
View File
@@ -3,9 +3,11 @@ timeout = 1000
bootnode = true
[relaychain.genesis.runtimeGenesis.patch.configuration.config]
max_validators_per_core = 1
needed_approvals = 3
[relaychain.genesis.runtimeGenesis.patch.configuration.config.scheduler_params]
max_validators_per_core = 1
[relaychain]
default_image = "{{ZOMBIENET_INTEGRATION_TEST_IMAGE}}"
chain = "rococo-local"