Struct polkadot_primitives::v8::SchedulerParams

pub struct SchedulerParams<BlockNumber> {
    pub group_rotation_frequency: BlockNumber,
    pub paras_availability_period: BlockNumber,
    pub max_validators_per_core: Option<u32>,
    pub lookahead: u32,
    pub num_cores: u32,
    pub max_availability_timeouts: 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 ttl: BlockNumber,
}

Scheduler configuration parameters. All coretime/ondemand parameters are here.

Fields

group_rotation_frequency: BlockNumber

How often parachain groups should be rotated across parachains.

Must be non-zero.

paras_availability_period: 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.

max_validators_per_core: Option<u32>

The maximum number of validators to have per core.

None means no maximum.

lookahead: u32

The amount of blocks ahead to schedule paras.

num_cores: u32

How many cores are managed by the coretime chain.

max_availability_timeouts: u32

The max number of times a claim can time out in availability.

on_demand_queue_max_size: u32

The maximum queue size of the pay as you go module.

on_demand_target_queue_utilization: Perbill

The target utilization of the spot price queue in percentages.

on_demand_fee_variability: Perbill

How quickly the fee rises in reaction to increased utilization. The lower the number the slower the increase.

on_demand_base_fee: Balance

The minimum amount needed to claim a slot in the spot pricing queue.

ttl: BlockNumber

The number of blocks a claim stays in the scheduler’s claim queue before getting cleared. This number should go reasonably higher than the number of blocks in the async backing lookahead.

Trait Implementations

impl<BlockNumber: Clone> Clone for SchedulerParams<BlockNumber>

fn clone(&self) -> SchedulerParams<BlockNumber>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<BlockNumber> Debug for SchedulerParams<BlockNumber>

where BlockNumber: Debug,

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<BlockNumber> Decode for SchedulerParams<BlockNumber>

where BlockNumber: Decode,

fn decode<__CodecInputEdqy: Input>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Self, Error>

Attempt to deserialise the value from input.

fn decode_into<I>( input: &mut I, dst: &mut MaybeUninit<Self>, ) -> Result<DecodeFinished, Error>

where I: Input,

Attempt to deserialize the value from input into a pre-allocated piece of memory.

fn skip<I>(input: &mut I) -> Result<(), Error>

where I: Input,

Attempt to skip the encoded value from input.

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

impl<BlockNumber: Default + From<u32>> Default for SchedulerParams<BlockNumber>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, BlockNumber> Deserialize<'de> for SchedulerParams<BlockNumber>

where BlockNumber: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<BlockNumber> Encode for SchedulerParams<BlockNumber>

where BlockNumber: Encode,

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding.

fn encode_to<__CodecOutputEdqy: Output + ?Sized>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

Convert self to a slice and append it to the destination.

fn encode(&self) -> Vec<u8>

Convert self to an owned vector.

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

Convert self to a slice and then invoke the given closure with it.

fn encoded_size(&self) -> usize

Calculates the encoded size.

impl<BlockNumber: PartialEq> PartialEq for SchedulerParams<BlockNumber>

fn eq(&self, other: &SchedulerParams<BlockNumber>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<BlockNumber> Serialize for SchedulerParams<BlockNumber>

where BlockNumber: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<BlockNumber> TypeInfo for SchedulerParams<BlockNumber>

where BlockNumber: TypeInfo + 'static,

type Identity = SchedulerParams<BlockNumber>

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl<BlockNumber: Copy> Copy for SchedulerParams<BlockNumber>

impl<BlockNumber> EncodeLike for SchedulerParams<BlockNumber>

where BlockNumber: Encode,

impl<BlockNumber> StructuralPartialEq for SchedulerParams<BlockNumber>