From a4763d82b3eb5403d5a28ae5e0223e8920b71259 Mon Sep 17 00:00:00 2001 From: Sabaun Taraki Date: Mon, 2 Oct 2023 19:37:16 +0300 Subject: [PATCH 1/8] refactor(wasm-gen, runtime-fuzzer): Increase successful messages execution rate in `runtime-fuzzer`. (#3383) --- scripts/src/test.sh | 2 +- utils/node-loader/src/utils.rs | 8 ++++---- utils/runtime-fuzzer/README.md | 2 +- utils/runtime-fuzzer/src/gear_calls.rs | 28 +++++++++++++++++--------- utils/wasm-gen/src/config/module.rs | 6 +++--- 5 files changed, 27 insertions(+), 19 deletions(-) diff --git a/scripts/src/test.sh b/scripts/src/test.sh index aa51385bfc8..a48ba352dbb 100755 --- a/scripts/src/test.sh +++ b/scripts/src/test.sh @@ -88,7 +88,7 @@ run_fuzzer() { cd $ROOT_DIR/utils/runtime-fuzzer if [ "$3" = "wlogs" ]; then - LOG_TARGETS="debug,syscalls,gear_wasm_gen=trace,runtime_fuzzer=trace,gear_backend_common=trace" + LOG_TARGETS="debug,syscalls,gear_wasm_gen=trace,runtime_fuzzer=trace,gear_core_backend=trace" else LOG_TARGETS="off" fi diff --git a/utils/node-loader/src/utils.rs b/utils/node-loader/src/utils.rs index e7640fa21c1..c9f99f99e9f 100644 --- a/utils/node-loader/src/utils.rs +++ b/utils/node-loader/src/utils.rs @@ -219,10 +219,10 @@ pub fn get_wasm_gen_config( (SysCallName::Leave, 0..=0), (SysCallName::Panic, 0..=0), (SysCallName::OomPanic, 0..=0), - (SysCallName::Send, 20..=30), + (SysCallName::Send, 10..=15), (SysCallName::Exit, 0..=1), - (SysCallName::Alloc, 5..=10), - (SysCallName::Free, 5..=10), + (SysCallName::Alloc, 3..=6), + (SysCallName::Free, 3..=6), ] .map(|(sys_call, range)| (InvocableSysCall::Loose(sys_call), range)) .into_iter(), @@ -230,7 +230,7 @@ pub fn get_wasm_gen_config( let mut params_config = SysCallsParamsConfig::default(); params_config.add_rule(ParamType::Alloc, (1..=10).into()); - params_config.add_rule(ParamType::Free, (initial_pages..=initial_pages + 25).into()); + params_config.add_rule(ParamType::Free, (initial_pages..=initial_pages + 50).into()); StandardGearWasmConfigsBundle { log_info: Some(format!("Gear program seed = '{seed}'")), diff --git a/utils/runtime-fuzzer/README.md b/utils/runtime-fuzzer/README.md index 8c141ea4f23..3f718836b53 100644 --- a/utils/runtime-fuzzer/README.md +++ b/utils/runtime-fuzzer/README.md @@ -23,7 +23,7 @@ dd if=/dev/urandom of=fuzz/corpus/main/fuzzer-seed-corpus bs=1 count=27000000 # Run fuzzer for at least 20 minutes and then press Ctrl-C to stop fuzzing. # You can also remove RUST_LOG to avoid printing tons of logs on terminal. -RUST_LOG=debug,syscalls,gear_wasm_gen=trace,runtime_fuzzer=trace,gear_backend_common=trace \ +RUST_LOG=debug,syscalls,gear_wasm_gen=trace,runtime_fuzzer=trace,gear_core_backend=trace \ cargo fuzz run \ --release \ --sanitizer=none \ diff --git a/utils/runtime-fuzzer/src/gear_calls.rs b/utils/runtime-fuzzer/src/gear_calls.rs index 8490247b13d..239b9e51ba6 100644 --- a/utils/runtime-fuzzer/src/gear_calls.rs +++ b/utils/runtime-fuzzer/src/gear_calls.rs @@ -43,6 +43,14 @@ use gear_wasm_gen::{ const MAX_PAYLOAD_SIZE: usize = 512 * 1024; static_assertions::const_assert!(MAX_PAYLOAD_SIZE <= gear_core::message::MAX_PAYLOAD_SIZE); +/// Maximum salt size for the fuzzer - 512 bytes. +/// +/// There's no need in large salts as we have only 35 extrinsics +/// for one run. Also small salt will make overall size of the +/// corpus smaller. +const MAX_SALT_SIZE: usize = 512; +static_assertions::const_assert!(MAX_SALT_SIZE <= gear_core::message::MAX_PAYLOAD_SIZE); + /// This trait provides ability for [`ExtrinsicGenerator`]s to fetch messages /// from mailbox, for example [`UploadProgramGenerator`] and /// [`ClaimValueGenerator`] use it. @@ -238,8 +246,11 @@ impl UploadProgramGenerator { } const fn unstructured_size_hint(&self) -> usize { - // 1024 KiB for payload and salt and 50 KiB for code. - 1080 * 1024 + // Max code size - 50 KiB. + const MAX_CODE_SIZE: usize = 50 * 1024; + const AUXILIARY_SIZE: usize = 512; + + MAX_CODE_SIZE + MAX_PAYLOAD_SIZE + MAX_SALT_SIZE + AUXILIARY_SIZE } } @@ -377,7 +388,7 @@ fn arbitrary_message_id_from_mailbox( } fn arbitrary_salt(u: &mut Unstructured) -> Result> { - arbitrary_limited_bytes(u, MAX_PAYLOAD_SIZE) + arbitrary_limited_bytes(u, MAX_SALT_SIZE) } fn arbitrary_payload(u: &mut Unstructured) -> Result> { @@ -400,10 +411,10 @@ fn config( (SysCallName::Leave, 0..=0), (SysCallName::Panic, 0..=0), (SysCallName::OomPanic, 0..=0), - (SysCallName::Send, 20..=30), + (SysCallName::Send, 10..=15), (SysCallName::Exit, 0..=1), - (SysCallName::Alloc, 20..=30), - (SysCallName::Free, 20..=30), + (SysCallName::Alloc, 3..=6), + (SysCallName::Free, 3..=6), ] .map(|(sys_call, range)| (InvocableSysCall::Loose(sys_call), range)) .into_iter(), @@ -411,10 +422,7 @@ fn config( let mut params_config = SysCallsParamsConfig::default(); params_config.add_rule(ParamType::Alloc, (10..=20).into()); - params_config.add_rule( - ParamType::Free, - (initial_pages..=initial_pages + 250).into(), - ); + params_config.add_rule(ParamType::Free, (initial_pages..=initial_pages + 35).into()); let existing_addresses = NonEmpty::collect( programs diff --git a/utils/wasm-gen/src/config/module.rs b/utils/wasm-gen/src/config/module.rs index 46ac8f927f7..4690382a667 100644 --- a/utils/wasm-gen/src/config/module.rs +++ b/utils/wasm-gen/src/config/module.rs @@ -368,9 +368,9 @@ impl Default for SelectableParams { allowed_instructions: vec![ Numeric, Reference, Parametric, Variable, Table, Memory, Control, ], - max_instructions: 100_000, - min_funcs: 15, - max_funcs: 30, + max_instructions: 500, + min_funcs: 3, + max_funcs: 5, unreachable_enabled: true, } } From 54ad44509ccefc8c7d798d4ac368bf4999beacc0 Mon Sep 17 00:00:00 2001 From: mertwole <33563701+mertwole@users.noreply.github.com> Date: Tue, 3 Oct 2023 01:44:48 -0700 Subject: [PATCH 2/8] feat(wasm-instrument): Provide more info about syscall signatures (#3385) --- utils/wasm-gen/src/generator/syscalls.rs | 76 +++- .../src/generator/syscalls/invocator.rs | 26 +- utils/wasm-instrument/src/syscalls.rs | 392 ++++++++++++++---- utils/wasm-instrument/src/tests.rs | 7 +- 4 files changed, 388 insertions(+), 113 deletions(-) diff --git a/utils/wasm-gen/src/generator/syscalls.rs b/utils/wasm-gen/src/generator/syscalls.rs index 9fe6f122b74..e85c5bba222 100644 --- a/utils/wasm-gen/src/generator/syscalls.rs +++ b/utils/wasm-gen/src/generator/syscalls.rs @@ -42,7 +42,7 @@ pub use additional_data::*; pub use imports::*; pub use invocator::*; -use gear_wasm_instrument::syscalls::{ParamType, SysCallName, SysCallSignature}; +use gear_wasm_instrument::syscalls::{ParamType, PtrInfo, PtrType, SysCallName, SysCallSignature}; /// Type of invocable sys-call. /// @@ -79,34 +79,64 @@ impl InvocableSysCall { InvocableSysCall::Loose(name) => name.signature(), InvocableSysCall::Precise(name) => match name { SysCallName::ReservationSend => SysCallSignature::gr([ - ParamType::Ptr(None), // Address of recipient and value (HashWithValue struct) - ParamType::Ptr(Some(2)), // Pointer to payload - ParamType::Size, // Size of the payload - ParamType::Delay, // Number of blocks to delay the sending for - ParamType::Gas, // Amount of gas to reserve - ParamType::Duration, // Duration of the reservation - ParamType::Ptr(None), // Address of error returned + // Address of recipient and value (HashWithValue struct) + ParamType::Ptr(PtrInfo::new_immutable(PtrType::HashWithValue)), + // Pointer to payload + ParamType::Ptr(PtrInfo::new_immutable(PtrType::BufferStart { + length_param_idx: 2, + })), + // Size of the payload + ParamType::Size, + // Number of blocks to delay the sending for + ParamType::Delay, + // Amount of gas to reserve + ParamType::Gas, + // Duration of the reservation + ParamType::Duration, + // Address of error returned + ParamType::Ptr(PtrInfo::new_mutable(PtrType::ErrorWithHash)), ]), SysCallName::ReservationReply => SysCallSignature::gr([ - ParamType::Ptr(None), // Address of value - ParamType::Ptr(Some(2)), // Pointer to payload - ParamType::Size, // Size of the payload - ParamType::Gas, // Amount of gas to reserve - ParamType::Duration, // Duration of the reservation - ParamType::Ptr(None), // Address of error returned + // Address of value + ParamType::Ptr(PtrInfo::new_immutable(PtrType::Value)), + // Pointer to payload + ParamType::Ptr(PtrInfo::new_immutable(PtrType::BufferStart { + length_param_idx: 2, + })), + // Size of the payload + ParamType::Size, + // Amount of gas to reserve + ParamType::Gas, + // Duration of the reservation + ParamType::Duration, + // Address of error returned + ParamType::Ptr(PtrInfo::new_mutable(PtrType::ErrorWithHash)), ]), SysCallName::SendCommit => SysCallSignature::gr([ - ParamType::Ptr(None), // Address of recipient and value (HashWithValue struct) - ParamType::Ptr(Some(2)), // Pointer to payload - ParamType::Size, // Size of the payload - ParamType::Delay, // Number of blocks to delay the sending for - ParamType::Ptr(None), // Address of error returned + // Address of recipient and value (HashWithValue struct) + ParamType::Ptr(PtrInfo::new_immutable(PtrType::HashWithValue)), + // Address of value + ParamType::Ptr(PtrInfo::new_immutable(PtrType::Value)), + // Pointer to payload + ParamType::Ptr(PtrInfo::new_immutable(PtrType::BufferStart { + length_param_idx: 2, + })), + // Size of the payload + ParamType::Size, + // Number of blocks to delay the sending for + ParamType::Delay, + // Address of error returned, `ErrorCode` here because underlying syscalls have different error types + ParamType::Ptr(PtrInfo::new_mutable(PtrType::ErrorCode)), ]), SysCallName::SendCommitWGas => SysCallSignature::gr([ - ParamType::Ptr(None), // Address of recipient and value (HashWithValue struct) - ParamType::Delay, // Number of blocks to delay the sending for - ParamType::Gas, // Amount of gas to reserve - ParamType::Ptr(None), // Address of error returned + // Address of recipient and value (HashWithValue struct) + ParamType::Ptr(PtrInfo::new_immutable(PtrType::HashWithValue)), + // Number of blocks to delay the sending for + ParamType::Delay, + // Amount of gas to reserve + ParamType::Gas, + // Address of error returned, `ErrorCode` here because underlying syscalls have different error types + ParamType::Ptr(PtrInfo::new_mutable(PtrType::ErrorCode)), ]), _ => unimplemented!(), }, diff --git a/utils/wasm-gen/src/generator/syscalls/invocator.rs b/utils/wasm-gen/src/generator/syscalls/invocator.rs index d479812b2f3..be68e480bf9 100644 --- a/utils/wasm-gen/src/generator/syscalls/invocator.rs +++ b/utils/wasm-gen/src/generator/syscalls/invocator.rs @@ -29,7 +29,7 @@ use crate::{ use arbitrary::{Result, Unstructured}; use gear_wasm_instrument::{ parity_wasm::elements::{BlockType, Instruction, Internal, ValueType}, - syscalls::{ParamType, SysCallName, SysCallSignature}, + syscalls::{ParamType, PtrInfo, PtrType, SysCallName, SysCallSignature}, }; use std::{ collections::{btree_map::Entry, BTreeMap, BinaryHeap}, @@ -64,16 +64,18 @@ pub(crate) fn process_sys_call_params( ParamType::Alloc => ProcessedSysCallParams::Alloc { allowed_values: params_config.get_rule(¶m), }, - ParamType::Ptr(maybe_idx) => maybe_idx - .map(|_| { - // skipping next as we don't need the following `Size` param, - // because it will be chosen in accordance to the wasm module - // memory pages config. - skip_next_param = true; - - ProcessedSysCallParams::MemoryArray - }) - .unwrap_or(ProcessedSysCallParams::MemoryPtrValue), + ParamType::Ptr(PtrInfo { + ty: PtrType::BufferStart { .. }, + .. + }) => { + // skipping next as we don't need the following `Size` param, + // because it will be chosen in accordance to the wasm module + // memory pages config. + skip_next_param = true; + + ProcessedSysCallParams::MemoryArray + } + ParamType::Ptr(_) => ProcessedSysCallParams::MemoryPtrValue, _ => ProcessedSysCallParams::Value { value_type: param.into(), allowed_values: params_config.get_rule(¶m), @@ -565,7 +567,7 @@ impl<'a, 'b> SysCallsInvocator<'a, 'b> { params .last() .expect("The last argument of fallible syscall must be pointer to error code"), - ParamType::Ptr(None) + ParamType::Ptr(_) )); assert_eq!(params.len(), param_setters.len()); diff --git a/utils/wasm-instrument/src/syscalls.rs b/utils/wasm-instrument/src/syscalls.rs index 444c6873386..6d1667a3002 100644 --- a/utils/wasm-instrument/src/syscalls.rs +++ b/utils/wasm-instrument/src/syscalls.rs @@ -240,89 +240,259 @@ impl SysCallName { match self { Self::Alloc => SysCallSignature::system([Alloc], [I32]), Self::Free => SysCallSignature::system([Free], [I32]), - Self::Debug => SysCallSignature::gr([Ptr(Some(1)), Size]), - Self::Panic => SysCallSignature::gr([Ptr(Some(1)), Size]), + Self::Debug => SysCallSignature::gr([ + Ptr(PtrInfo::new_immutable(PtrType::BufferStart { + length_param_idx: 1, + })), + Size, + ]), + Self::Panic => SysCallSignature::gr([ + Ptr(PtrInfo::new_immutable(PtrType::BufferStart { + length_param_idx: 1, + })), + Size, + ]), Self::OomPanic => SysCallSignature::gr([]), - Self::BlockHeight => SysCallSignature::gr([Ptr(None)]), - Self::BlockTimestamp => SysCallSignature::gr([Ptr(None)]), - Self::Exit => SysCallSignature::gr([Ptr(None)]), - Self::GasAvailable => SysCallSignature::gr([Ptr(None)]), - Self::PayProgramRent => SysCallSignature::gr([Ptr(None), Ptr(None)]), - Self::ProgramId => SysCallSignature::gr([Ptr(None)]), + Self::BlockHeight => { + SysCallSignature::gr([Ptr(PtrInfo::new_mutable(PtrType::BlockNumber))]) + } + Self::BlockTimestamp => { + SysCallSignature::gr([Ptr(PtrInfo::new_mutable(PtrType::BlockTimestamp))]) + } + Self::Exit => SysCallSignature::gr([Ptr(PtrInfo::new_immutable(PtrType::Hash))]), + Self::GasAvailable => SysCallSignature::gr([Ptr(PtrInfo::new_mutable(PtrType::Gas))]), + Self::PayProgramRent => SysCallSignature::gr([ + Ptr(PtrInfo::new_immutable(PtrType::HashWithValue)), + Ptr(PtrInfo::new_mutable(PtrType::ErrorWithBlockNumberAndValue)), + ]), + Self::ProgramId => SysCallSignature::gr([Ptr(PtrInfo::new_mutable(PtrType::Hash))]), Self::Leave => SysCallSignature::gr([]), - Self::ValueAvailable => SysCallSignature::gr([Ptr(None)]), + Self::ValueAvailable => { + SysCallSignature::gr([Ptr(PtrInfo::new_mutable(PtrType::Value))]) + } Self::Wait => SysCallSignature::gr([]), Self::WaitUpTo => SysCallSignature::gr([Duration]), Self::WaitFor => SysCallSignature::gr([Duration]), - Self::Wake => SysCallSignature::gr([Ptr(None), Delay, Ptr(None)]), - Self::ReplyCode => SysCallSignature::gr([Ptr(None)]), - Self::SignalCode => SysCallSignature::gr([Ptr(None)]), - Self::MessageId => SysCallSignature::gr([Ptr(None)]), - Self::Read => SysCallSignature::gr([MessagePosition, Size, Ptr(None), Ptr(None)]), - Self::Reply => SysCallSignature::gr([Ptr(Some(1)), Size, Ptr(None), Ptr(None)]), - Self::ReplyInput => SysCallSignature::gr([Size, Size, Ptr(None), Ptr(None)]), - Self::ReplyWGas => { - SysCallSignature::gr([Ptr(Some(1)), Size, Gas, Ptr(None), Ptr(None)]) - } - Self::ReplyInputWGas => SysCallSignature::gr([Size, Size, Gas, Ptr(None), Ptr(None)]), - Self::ReplyCommit => SysCallSignature::gr([Ptr(None), Ptr(None)]), - Self::ReplyCommitWGas => SysCallSignature::gr([Gas, Ptr(None), Ptr(None)]), - Self::ReservationReply => { - SysCallSignature::gr([Ptr(None), Ptr(Some(2)), Size, Ptr(None)]) + Self::Wake => SysCallSignature::gr([ + Ptr(PtrInfo::new_immutable(PtrType::Hash)), + Delay, + Ptr(PtrInfo::new_mutable(PtrType::ErrorCode)), + ]), + Self::ReplyCode => { + SysCallSignature::gr([Ptr(PtrInfo::new_mutable(PtrType::ErrorWithReplyCode))]) } - Self::ReservationReplyCommit => SysCallSignature::gr([Ptr(None), Ptr(None)]), - Self::ReplyPush => SysCallSignature::gr([Ptr(Some(1)), Size, Ptr(None)]), - Self::ReplyPushInput => SysCallSignature::gr([Size, Size, Ptr(None)]), - Self::ReplyTo => SysCallSignature::gr([Ptr(None)]), - Self::SignalFrom => SysCallSignature::gr([Ptr(None)]), - Self::Send => SysCallSignature::gr([Ptr(None), Ptr(Some(2)), Size, Delay, Ptr(None)]), - Self::SendInput => SysCallSignature::gr([Ptr(None), Size, Size, Delay, Ptr(None)]), - Self::SendWGas => { - SysCallSignature::gr([Ptr(None), Ptr(Some(2)), Size, Gas, Delay, Ptr(None)]) + Self::SignalCode => { + SysCallSignature::gr([Ptr(PtrInfo::new_mutable(PtrType::ErrorWithSignalCode))]) } - Self::SendInputWGas => { - SysCallSignature::gr([Ptr(None), Size, Size, Gas, Delay, Ptr(None)]) + Self::MessageId => SysCallSignature::gr([Ptr(PtrInfo::new_mutable(PtrType::Hash))]), + Self::Read => SysCallSignature::gr([ + MessagePosition, + Size, + // TODO #3375, the PtrType::BlockNumber is incorrect here. + // Should be: + // Ptr(PtrInfo::new_mutable(PtrType::BufferStart { + // length_param_idx: 1, + // })) + Ptr(PtrInfo::new_mutable(PtrType::BlockNumber)), + Ptr(PtrInfo::new_mutable(PtrType::ErrorCode)), + ]), + Self::Reply => SysCallSignature::gr([ + Ptr(PtrInfo::new_immutable(PtrType::BufferStart { + length_param_idx: 1, + })), + Size, + Ptr(PtrInfo::new_immutable(PtrType::Value)), + Ptr(PtrInfo::new_mutable(PtrType::ErrorWithHash)), + ]), + Self::ReplyInput => SysCallSignature::gr([ + Size, + Size, + Ptr(PtrInfo::new_immutable(PtrType::Value)), + Ptr(PtrInfo::new_mutable(PtrType::ErrorWithHash)), + ]), + Self::ReplyWGas => SysCallSignature::gr([ + Ptr(PtrInfo::new_immutable(PtrType::BufferStart { + length_param_idx: 1, + })), + Size, + Gas, + Ptr(PtrInfo::new_immutable(PtrType::Value)), + Ptr(PtrInfo::new_mutable(PtrType::ErrorWithHash)), + ]), + Self::ReplyInputWGas => SysCallSignature::gr([ + Size, + Size, + Gas, + Ptr(PtrInfo::new_immutable(PtrType::Value)), + Ptr(PtrInfo::new_mutable(PtrType::ErrorWithHash)), + ]), + Self::ReplyCommit => SysCallSignature::gr([ + Ptr(PtrInfo::new_immutable(PtrType::Value)), + Ptr(PtrInfo::new_mutable(PtrType::ErrorWithHash)), + ]), + Self::ReplyCommitWGas => SysCallSignature::gr([ + Gas, + Ptr(PtrInfo::new_immutable(PtrType::Value)), + Ptr(PtrInfo::new_mutable(PtrType::ErrorWithHash)), + ]), + Self::ReservationReply => SysCallSignature::gr([ + Ptr(PtrInfo::new_immutable(PtrType::HashWithValue)), + Ptr(PtrInfo::new_immutable(PtrType::BufferStart { + length_param_idx: 2, + })), + Size, + Ptr(PtrInfo::new_mutable(PtrType::ErrorWithHash)), + ]), + Self::ReservationReplyCommit => SysCallSignature::gr([ + Ptr(PtrInfo::new_immutable(PtrType::HashWithValue)), + Ptr(PtrInfo::new_mutable(PtrType::ErrorWithHash)), + ]), + Self::ReplyPush => SysCallSignature::gr([ + Ptr(PtrInfo::new_immutable(PtrType::BufferStart { + length_param_idx: 1, + })), + Size, + Ptr(PtrInfo::new_mutable(PtrType::ErrorCode)), + ]), + Self::ReplyPushInput => { + SysCallSignature::gr([Size, Size, Ptr(PtrInfo::new_mutable(PtrType::ErrorCode))]) } - Self::SendCommit => SysCallSignature::gr([Handler, Ptr(None), Delay, Ptr(None)]), - Self::SendCommitWGas => { - SysCallSignature::gr([Handler, Ptr(None), Gas, Delay, Ptr(None)]) + Self::ReplyTo => { + SysCallSignature::gr([Ptr(PtrInfo::new_mutable(PtrType::ErrorWithHash))]) } - Self::SendInit => SysCallSignature::gr([Ptr(None)]), - Self::SendPush => SysCallSignature::gr([Handler, Ptr(Some(2)), Size, Ptr(None)]), - Self::SendPushInput => SysCallSignature::gr([Handler, Size, Size, Ptr(None)]), - Self::ReservationSend => { - SysCallSignature::gr([Ptr(None), Ptr(Some(2)), Size, Delay, Ptr(None)]) + Self::SignalFrom => { + SysCallSignature::gr([Ptr(PtrInfo::new_mutable(PtrType::ErrorWithHash))]) } - Self::ReservationSendCommit => { - SysCallSignature::gr([Handler, Ptr(None), Delay, Ptr(None)]) + Self::Send => SysCallSignature::gr([ + Ptr(PtrInfo::new_immutable(PtrType::HashWithValue)), + Ptr(PtrInfo::new_immutable(PtrType::BufferStart { + length_param_idx: 2, + })), + Size, + Delay, + Ptr(PtrInfo::new_mutable(PtrType::ErrorWithHash)), + ]), + Self::SendInput => SysCallSignature::gr([ + Ptr(PtrInfo::new_immutable(PtrType::HashWithValue)), + Size, + Size, + Delay, + Ptr(PtrInfo::new_mutable(PtrType::ErrorWithHash)), + ]), + Self::SendWGas => SysCallSignature::gr([ + Ptr(PtrInfo::new_immutable(PtrType::HashWithValue)), + Ptr(PtrInfo::new_immutable(PtrType::BufferStart { + length_param_idx: 2, + })), + Size, + Gas, + Delay, + Ptr(PtrInfo::new_mutable(PtrType::ErrorWithHash)), + ]), + Self::SendInputWGas => SysCallSignature::gr([ + Ptr(PtrInfo::new_immutable(PtrType::HashWithValue)), + Size, + Size, + Gas, + Delay, + Ptr(PtrInfo::new_mutable(PtrType::ErrorWithHash)), + ]), + Self::SendCommit => SysCallSignature::gr([ + Handler, + Ptr(PtrInfo::new_immutable(PtrType::HashWithValue)), + Delay, + Ptr(PtrInfo::new_mutable(PtrType::ErrorWithHash)), + ]), + Self::SendCommitWGas => SysCallSignature::gr([ + Handler, + Ptr(PtrInfo::new_immutable(PtrType::HashWithValue)), + Gas, + Delay, + Ptr(PtrInfo::new_mutable(PtrType::ErrorWithHash)), + ]), + Self::SendInit => { + SysCallSignature::gr([Ptr(PtrInfo::new_mutable(PtrType::ErrorWithHandle))]) } - Self::Size => SysCallSignature::gr([Ptr(None)]), - Self::Source => SysCallSignature::gr([Ptr(None)]), - Self::Value => SysCallSignature::gr([Ptr(None)]), + Self::SendPush => SysCallSignature::gr([ + Handler, + Ptr(PtrInfo::new_immutable(PtrType::BufferStart { + length_param_idx: 2, + })), + Size, + Ptr(PtrInfo::new_mutable(PtrType::ErrorCode)), + ]), + Self::SendPushInput => SysCallSignature::gr([ + Handler, + Size, + Size, + Ptr(PtrInfo::new_mutable(PtrType::ErrorCode)), + ]), + Self::ReservationSend => SysCallSignature::gr([ + Ptr(PtrInfo::new_immutable(PtrType::TwoHashesWithValue)), + Ptr(PtrInfo::new_immutable(PtrType::BufferStart { + length_param_idx: 2, + })), + Size, + Delay, + Ptr(PtrInfo::new_mutable(PtrType::ErrorWithHash)), + ]), + Self::ReservationSendCommit => SysCallSignature::gr([ + Handler, + Ptr(PtrInfo::new_immutable(PtrType::TwoHashesWithValue)), + Delay, + Ptr(PtrInfo::new_mutable(PtrType::ErrorWithHash)), + ]), + Self::Size => SysCallSignature::gr([Ptr(PtrInfo::new_mutable(PtrType::Length))]), + Self::Source => SysCallSignature::gr([Ptr(PtrInfo::new_mutable(PtrType::Hash))]), + Self::Value => SysCallSignature::gr([Ptr(PtrInfo::new_mutable(PtrType::Value))]), Self::CreateProgram => SysCallSignature::gr([ - Ptr(None), - Ptr(Some(2)), + Ptr(PtrInfo::new_immutable(PtrType::HashWithValue)), + Ptr(PtrInfo::new_immutable(PtrType::BufferStart { + length_param_idx: 2, + })), Size, - Ptr(Some(4)), + Ptr(PtrInfo::new_immutable(PtrType::BufferStart { + length_param_idx: 4, + })), Size, Delay, - Ptr(None), + Ptr(PtrInfo::new_mutable(PtrType::ErrorWithTwoHashes)), ]), Self::CreateProgramWGas => SysCallSignature::gr([ - Ptr(None), - Ptr(Some(2)), + Ptr(PtrInfo::new_immutable(PtrType::HashWithValue)), + Ptr(PtrInfo::new_immutable(PtrType::BufferStart { + length_param_idx: 2, + })), Size, - Ptr(Some(4)), + Ptr(PtrInfo::new_immutable(PtrType::BufferStart { + length_param_idx: 4, + })), Size, Gas, Delay, - Ptr(None), + Ptr(PtrInfo::new_mutable(PtrType::ErrorWithTwoHashes)), + ]), + Self::ReplyDeposit => SysCallSignature::gr([ + Ptr(PtrInfo::new_immutable(PtrType::Hash)), + Gas, + Ptr(PtrInfo::new_mutable(PtrType::ErrorCode)), + ]), + Self::ReserveGas => SysCallSignature::gr([ + Gas, + Duration, + Ptr(PtrInfo::new_mutable(PtrType::ErrorWithHash)), + ]), + Self::UnreserveGas => SysCallSignature::gr([ + Ptr(PtrInfo::new_immutable(PtrType::Hash)), + Ptr(PtrInfo::new_mutable(PtrType::ErrorWithGas)), + ]), + Self::SystemReserveGas => { + SysCallSignature::gr([Gas, Ptr(PtrInfo::new_mutable(PtrType::ErrorCode))]) + } + Self::Random => SysCallSignature::gr([ + Ptr(PtrInfo::new_immutable(PtrType::Hash)), + Ptr(PtrInfo::new_mutable(PtrType::BlockNumberWithHash)), ]), - Self::ReplyDeposit => SysCallSignature::gr([Ptr(None), Gas, Ptr(None)]), - Self::ReserveGas => SysCallSignature::gr([Gas, Duration, Ptr(None)]), - Self::UnreserveGas => SysCallSignature::gr([Ptr(None), Ptr(None)]), - Self::SystemReserveGas => SysCallSignature::gr([Gas, Ptr(None)]), - Self::Random => SysCallSignature::gr([Ptr(None), Ptr(None)]), other => panic!("Unknown syscall: '{:?}'", other), } } @@ -343,23 +513,93 @@ impl SysCallName { /// Syscall param type. /// -/// `Ptr` is usually used to point to the beginning of the array in memory. -/// In order to distinguish between pointer to the memory array and pointer -/// to some value, `Ptr` was defined as a tuple-like struct that owns an -/// optional index of the memory array size parameter. So if current sys-call -/// doesn't accept any memory array as an argument, then pointer parameter will -/// be `Ptr(None)`. +/// `Ptr` variant contains additional data about the type this pointer +/// belongs to. See [`PtrInfo`] and [`PtrType`] for more details. #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)] pub enum ParamType { - Size, // i32 buffers size in memory - Ptr(Option), // i32 pointer - Gas, // i64 gas amount - MessagePosition, // i32 message position - Duration, // i32 duration in blocks - Delay, // i32 delay in blocks - Handler, // i32 handler number - Alloc, // i32 alloc pages - Free, // i32 free page + Size, // i32 buffers size in memory + Ptr(PtrInfo), // i32 pointer + Gas, // i64 gas amount + MessagePosition, // i32 message position + Duration, // i32 duration in blocks + Delay, // i32 delay in blocks + Handler, // i32 handler number + Alloc, // i32 alloc pages + Free, // i32 free page +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)] +pub struct PtrInfo { + pub mutable: bool, + pub ty: PtrType, +} + +impl PtrInfo { + pub fn new_immutable(ty: PtrType) -> PtrInfo { + PtrInfo { mutable: false, ty } + } + + pub fn new_mutable(ty: PtrType) -> PtrInfo { + PtrInfo { mutable: true, ty } + } +} + +/// Pointer type. +/// +/// Used to distinguish between different pointer types in the syscall signatures. +/// Basically it responds to different types from `gsys`. +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)] +pub enum PtrType { + BlockNumber, + BlockTimestamp, + BufferStart { length_param_idx: usize }, + Hash, + Gas, + Length, + Value, + + BlockNumberWithHash, + HashWithValue, + TwoHashes, + TwoHashesWithValue, + + ErrorCode, + + ErrorWithReplyCode, + ErrorWithSignalCode, + ErrorWithGas, + ErrorWithHandle, + ErrorWithHash, + ErrorWithTwoHashes, + ErrorWithBlockNumberAndValue, +} + +impl PtrType { + pub fn is_error(self) -> bool { + use PtrType::*; + + match self { + ErrorCode + | ErrorWithReplyCode + | ErrorWithSignalCode + | ErrorWithGas + | ErrorWithHandle + | ErrorWithHash + | ErrorWithTwoHashes + | ErrorWithBlockNumberAndValue => true, + BlockNumber + | BlockTimestamp + | BufferStart { .. } + | Hash + | Gas + | Length + | Value + | BlockNumberWithHash + | HashWithValue + | TwoHashes + | TwoHashesWithValue => false, + } + } } impl From for ValueType { diff --git a/utils/wasm-instrument/src/tests.rs b/utils/wasm-instrument/src/tests.rs index a29fd16c75b..7ff872f5f8d 100644 --- a/utils/wasm-instrument/src/tests.rs +++ b/utils/wasm-instrument/src/tests.rs @@ -19,7 +19,7 @@ use super::*; use crate::{ rules::CustomConstantCostRules, - syscalls::{ParamType, SysCallName}, + syscalls::{ParamType, PtrInfo, PtrType, SysCallName}, }; use alloc::format; use elements::Instruction::*; @@ -682,7 +682,10 @@ fn check_memory_array_pointers_definition_correctness() { .params .iter() .filter_map(|param_ty| match param_ty { - ParamType::Ptr(maybe_size_idx) if maybe_size_idx.is_some() => *maybe_size_idx, + ParamType::Ptr(PtrInfo { + ty: PtrType::BufferStart { length_param_idx }, + .. + }) => Some(*length_param_idx), _ => None, }); From 4c43268fa7fff8fc7c9be2a0ddc8d366c29dd938 Mon Sep 17 00:00:00 2001 From: Dennis Diatlov Date: Tue, 3 Oct 2023 13:00:35 +0100 Subject: [PATCH 3/8] feat(runtime): Introduce `PerformanceMultiplier` as `Config` constant (#3160) --- Cargo.lock | 1 + Cargo.toml | 1 + core-backend/src/mock.rs | 4 ++ core-processor/src/configs.rs | 5 +++ core-processor/src/executor.rs | 3 ++ core-processor/src/ext.rs | 8 ++++ core-processor/src/processing.rs | 2 + core/Cargo.toml | 5 ++- core/src/env.rs | 4 ++ core/src/lib.rs | 1 + core/src/percent.rs | 52 ++++++++++++++++++++++++++ gsdk/src/metadata/generated.rs | 11 ++++++ gtest/src/manager.rs | 2 + pallets/gear-debug/src/mock.rs | 2 + pallets/gear-scheduler/src/mock.rs | 2 + pallets/gear/src/benchmarking/mod.rs | 2 + pallets/gear/src/benchmarking/utils.rs | 1 + pallets/gear/src/lib.rs | 6 +++ pallets/gear/src/mock.rs | 2 + pallets/payment/src/mock.rs | 2 + runtime/gear/src/lib.rs | 3 ++ runtime/vara/src/lib.rs | 3 ++ 22 files changed, 120 insertions(+), 2 deletions(-) create mode 100644 core/src/percent.rs diff --git a/Cargo.lock b/Cargo.lock index 2a1e220ef61..7f0a3f8fa43 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3909,6 +3909,7 @@ dependencies = [ "hashbrown 0.14.0", "hex", "log", + "num-traits", "parity-scale-codec", "paste", "proptest", diff --git a/Cargo.toml b/Cargo.toml index d6d1f00418c..79fd4c5f919 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -453,6 +453,7 @@ heck = "0.4.1" # gsdk etc = "0.1.16" # gcli scale-decode = "0.7.0" # gsdk directories = "5.0.1" # utils/key-finder +num-traits = { version = "0.2", default-features = false } # gear-core [profile.release] panic = "unwind" diff --git a/core-backend/src/mock.rs b/core-backend/src/mock.rs index 4264aabedab..e1b8177b407 100644 --- a/core-backend/src/mock.rs +++ b/core-backend/src/mock.rs @@ -33,6 +33,7 @@ use gear_core::{ memory::{Memory, MemoryError, MemoryInterval}, message::{HandlePacket, InitPacket, ReplyPacket}, pages::{PageNumber, PageU32Size, WasmPage, WASM_PAGE_SIZE}, + percent::Percent, }; use gear_core_errors::{ReplyCode, SignalCode}; use gear_lazy_pages_common::ProcessAccessError; @@ -120,6 +121,9 @@ impl Externalities for MockExt { fn block_timestamp(&self) -> Result { Ok(0) } + fn performance_multiplier(&self) -> Result { + Ok(Percent::new(100)) + } fn send_init(&mut self) -> Result { Ok(0) } diff --git a/core-processor/src/configs.rs b/core-processor/src/configs.rs index 5d04d70271b..153d7fc23af 100644 --- a/core-processor/src/configs.rs +++ b/core-processor/src/configs.rs @@ -22,6 +22,7 @@ use alloc::{collections::BTreeSet, vec::Vec}; use gear_core::{ costs::{CostPerPage, HostFnWeights}, pages::{GearPage, WasmPage}, + percent::Percent, }; use gear_lazy_pages_common::LazyPagesWeights; use gear_wasm_instrument::syscalls::SysCallName; @@ -144,6 +145,8 @@ impl PageCosts { pub struct ExecutionSettings { /// Contextual block information. pub block_info: BlockInfo, + /// Performance multiplier. + pub performance_multiplier: Percent, /// Max amount of pages in program memory during execution. pub max_pages: WasmPage, /// Pages costs. @@ -176,6 +179,8 @@ pub struct ExecutionSettings { pub struct BlockConfig { /// Block info. pub block_info: BlockInfo, + /// Performance multiplier. + pub performance_multiplier: Percent, /// Max allowed page numbers for wasm program. pub max_pages: WasmPage, /// Allocations config. diff --git a/core-processor/src/executor.rs b/core-processor/src/executor.rs index 1f71adaf08f..05099bf8997 100644 --- a/core-processor/src/executor.rs +++ b/core-processor/src/executor.rs @@ -42,6 +42,7 @@ use gear_core::{ WasmEntryPoint, }, pages::{PageU32Size, WasmPage}, + percent::Percent, program::Program, reservation::GasReserver, }; @@ -205,6 +206,7 @@ where allocations_context, message_context, block_info: settings.block_info, + performance_multiplier: settings.performance_multiplier, max_pages: settings.max_pages, page_costs: settings.page_costs, existential_deposit: settings.existential_deposit, @@ -399,6 +401,7 @@ where ContextSettings::new(0, 0, 0, 0, 0, 0), ), block_info, + performance_multiplier: Percent::new(100), max_pages: 512.into(), page_costs: Default::default(), existential_deposit: Default::default(), diff --git a/core-processor/src/ext.rs b/core-processor/src/ext.rs index 55d1f96dec9..b1af302f147 100644 --- a/core-processor/src/ext.rs +++ b/core-processor/src/ext.rs @@ -40,6 +40,7 @@ use gear_core::{ MessageContext, Packet, ReplyPacket, }, pages::{GearPage, PageU32Size, WasmPage}, + percent::Percent, reservation::GasReserver, }; use gear_core_backend::{ @@ -75,6 +76,8 @@ pub struct ProcessorContext { pub message_context: MessageContext, /// Block info. pub block_info: BlockInfo, + /// Performance multiplier. + pub performance_multiplier: Percent, /// Max allowed wasm memory pages. pub max_pages: WasmPage, /// Allocations config. @@ -135,6 +138,7 @@ impl ProcessorContext { ContextSettings::new(0, 0, 0, 0, 0, 0), ), block_info: Default::default(), + performance_multiplier: Percent::new(100), max_pages: 512.into(), page_costs: Default::default(), existential_deposit: 0, @@ -725,6 +729,10 @@ impl Externalities for Ext { Ok(self.context.block_info.timestamp) } + fn performance_multiplier(&self) -> Result { + Ok(self.context.performance_multiplier) + } + fn send_init(&mut self) -> Result { let handle = self.context.message_context.send_init()?; Ok(handle) diff --git a/core-processor/src/processing.rs b/core-processor/src/processing.rs index 8becd057446..befb3685610 100644 --- a/core-processor/src/processing.rs +++ b/core-processor/src/processing.rs @@ -57,6 +57,7 @@ where let BlockConfig { block_info, + performance_multiplier, max_pages, page_costs, existential_deposit, @@ -75,6 +76,7 @@ where let execution_settings = ExecutionSettings { block_info, + performance_multiplier, existential_deposit, max_pages, page_costs, diff --git a/core/Cargo.toml b/core/Cargo.toml index 22a2d47f2ee..897cd2e48c8 100644 --- a/core/Cargo.toml +++ b/core/Cargo.toml @@ -22,12 +22,13 @@ wasmparser.workspace = true hex = { workspace = true, features = ["alloc"] } hashbrown.workspace = true static_assertions.workspace = true -paste = { workspace = true } +paste.workspace = true enum-iterator.workspace = true byteorder.workspace = true +num-traits.workspace = true # Optional dependencies -serde = { workspace = true, features = [ "derive" ], optional = true } +serde = { workspace = true, features = ["derive"], optional = true } [dev-dependencies] wabt.workspace = true diff --git a/core/src/env.rs b/core/src/env.rs index b17a5b7b600..f05993aae27 100644 --- a/core/src/env.rs +++ b/core/src/env.rs @@ -23,6 +23,7 @@ use crate::{ memory::Memory, message::{HandlePacket, InitPacket, MessageContext, Payload, ReplyPacket}, pages::WasmPage, + percent::Percent, }; use alloc::collections::BTreeSet; use core::{fmt::Display, mem}; @@ -203,6 +204,9 @@ pub trait Externalities { /// Get the current block timestamp. fn block_timestamp(&self) -> Result; + /// Get current performance multiplier. + fn performance_multiplier(&self) -> Result; + /// Initialize a new incomplete message for another program and return its handle. fn send_init(&mut self) -> Result; diff --git a/core/src/lib.rs b/core/src/lib.rs index 1996e7492dd..47e982393ec 100644 --- a/core/src/lib.rs +++ b/core/src/lib.rs @@ -35,6 +35,7 @@ pub mod ids; pub mod memory; pub mod message; pub mod pages; +pub mod percent; pub mod program; pub mod reservation; diff --git a/core/src/percent.rs b/core/src/percent.rs new file mode 100644 index 00000000000..e63f218fd95 --- /dev/null +++ b/core/src/percent.rs @@ -0,0 +1,52 @@ +// This file is part of Gear. + +// Copyright (C) 2021-2023 Gear Technologies Inc. +// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0 + +// This program 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. + +// This program 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 this program. If not, see . + +//! Basic struct for working with integer percentages. + +use core::cmp::Ord; +use num_traits::{cast::NumCast, Num}; +use parity_scale_codec::{Decode, Encode}; +use scale_info::TypeInfo; + +/// Basic struct for working with integer percentages. +#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Encode, Decode, TypeInfo)] +pub struct Percent(u32); + +impl Percent { + /// Creates a new `Percent` from a `u32` value. The value can be + /// greater than 100. + pub fn new(value: u32) -> Self { + Self(value) + } + + /// Returns the inner `u16` value. + pub fn value(self) -> u32 { + self.0 + } + + /// Applies the percentage to the given value. + pub fn apply_to(&self, value: T) -> T { + (value * NumCast::from(self.0).unwrap()) / NumCast::from(100).unwrap() + } +} + +impl From for Percent { + fn from(value: u32) -> Self { + Self::new(value) + } +} diff --git a/gsdk/src/metadata/generated.rs b/gsdk/src/metadata/generated.rs index dc2bdd5bf5b..c7b4876eb1c 100644 --- a/gsdk/src/metadata/generated.rs +++ b/gsdk/src/metadata/generated.rs @@ -914,6 +914,17 @@ pub mod runtime_types { )] pub struct WasmPage(pub ::core::primitive::u32); } + pub mod percent { + use super::runtime_types; + #[derive( + ::subxt::ext::codec::CompactAs, + Debug, + crate::gp::Decode, + crate::gp::DecodeAsType, + crate::gp::Encode, + )] + pub struct Percent(pub ::core::primitive::u32); + } pub mod reservation { use super::runtime_types; #[derive(Debug, crate::gp::Decode, crate::gp::DecodeAsType, crate::gp::Encode)] diff --git a/gtest/src/manager.rs b/gtest/src/manager.rs index 4a45dda5dae..7563b5ded54 100644 --- a/gtest/src/manager.rs +++ b/gtest/src/manager.rs @@ -38,6 +38,7 @@ use gear_core::{ StoredMessage, }, pages::{GearPage, PageU32Size, WasmPage}, + percent::Percent, program::Program as CoreProgram, reservation::{GasReservationMap, GasReserver}, }; @@ -817,6 +818,7 @@ impl ExtManager { .expect("Unable to find gas limit for message"); let block_config = BlockConfig { block_info: self.block_info, + performance_multiplier: Percent::new(100), max_pages: TESTS_MAX_PAGES_NUMBER.into(), page_costs: PageCosts::new_for_tests(), existential_deposit: EXISTENTIAL_DEPOSIT, diff --git a/pallets/gear-debug/src/mock.rs b/pallets/gear-debug/src/mock.rs index 4d2571d8ad5..ae669dd7f33 100644 --- a/pallets/gear-debug/src/mock.rs +++ b/pallets/gear-debug/src/mock.rs @@ -116,6 +116,7 @@ parameter_types! { pub const MinimumPeriod: u64 = 500; pub const OutgoingLimit: u32 = 1024; pub const BlockGasLimit: u64 = 100_000_000_000; + pub const PerformanceMultiplier: u32 = 100; } impl pallet_timestamp::Config for Test { @@ -150,6 +151,7 @@ impl pallet_gear::Config for Test { type Randomness = TestRandomness; type WeightInfo = (); type OutgoingLimit = OutgoingLimit; + type PerformanceMultiplier = PerformanceMultiplier; type DebugInfo = super::Pallet; type Schedule = (); type CodeStorage = GearProgram; diff --git a/pallets/gear-scheduler/src/mock.rs b/pallets/gear-scheduler/src/mock.rs index 8ef9b7da76d..8b662f87b0b 100644 --- a/pallets/gear-scheduler/src/mock.rs +++ b/pallets/gear-scheduler/src/mock.rs @@ -121,6 +121,7 @@ impl pallet_gear_program::Config for Test { parameter_types! { pub const BlockGasLimit: u64 = 100_000_000_000; pub const OutgoingLimit: u32 = 1024; + pub const PerformanceMultiplier: u32 = 100; pub GearSchedule: pallet_gear::Schedule = >::default(); pub RentFreePeriod: BlockNumber = 1_000; pub RentCostPerBlock: Balance = 11; @@ -142,6 +143,7 @@ impl pallet_gear::Config for Test { type WeightInfo = (); type Schedule = GearSchedule; type OutgoingLimit = OutgoingLimit; + type PerformanceMultiplier = PerformanceMultiplier; type DebugInfo = (); type CodeStorage = GearProgram; type ProgramStorage = GearProgram; diff --git a/pallets/gear/src/benchmarking/mod.rs b/pallets/gear/src/benchmarking/mod.rs index 7a2c82c7c3a..71fde344dfd 100644 --- a/pallets/gear/src/benchmarking/mod.rs +++ b/pallets/gear/src/benchmarking/mod.rs @@ -92,6 +92,7 @@ use gear_core::{ memory::{AllocationsContext, Memory, PageBuf}, message::{ContextSettings, DispatchKind, IncomingDispatch, MessageContext}, pages::{GearPage, PageU32Size, WasmPage, GEAR_PAGE_SIZE, WASM_PAGE_SIZE}, + percent::Percent, reservation::GasReserver, }; use gear_core_backend::{ @@ -187,6 +188,7 @@ fn default_processor_context() -> ProcessorContext { ContextSettings::new(0, 0, 0, 0, 0, 0), ), block_info: Default::default(), + performance_multiplier: Percent::new(100), max_pages: TESTS_MAX_PAGES_NUMBER.into(), page_costs: PageCosts::new_for_tests(), existential_deposit: 0, diff --git a/pallets/gear/src/benchmarking/utils.rs b/pallets/gear/src/benchmarking/utils.rs index ad918924ca8..a6df303d2ac 100644 --- a/pallets/gear/src/benchmarking/utils.rs +++ b/pallets/gear/src/benchmarking/utils.rs @@ -63,6 +63,7 @@ where BlockConfig { block_info, + performance_multiplier: T::PerformanceMultiplier::get(), max_pages: T::Schedule::get().limits.memory_pages.into(), page_costs: T::Schedule::get().memory_weights.into(), existential_deposit, diff --git a/pallets/gear/src/lib.rs b/pallets/gear/src/lib.rs index ff267066288..5bef97c2c9c 100644 --- a/pallets/gear/src/lib.rs +++ b/pallets/gear/src/lib.rs @@ -72,6 +72,7 @@ use gear_core::{ memory::PageBuf, message::*, pages::{GearPage, WasmPage}, + percent::Percent, }; use manager::{CodeInfo, QueuePostProcessingData}; use primitive_types::H256; @@ -167,6 +168,10 @@ pub mod pallet { #[pallet::constant] type OutgoingLimit: Get; + /// Performance multiplier. + #[pallet::constant] + type PerformanceMultiplier: Get; + type DebugInfo: DebugInfo; /// Implementation of a storage for program binary codes. @@ -1028,6 +1033,7 @@ pub mod pallet { BlockConfig { block_info, + performance_multiplier: T::PerformanceMultiplier::get(), max_pages: schedule.limits.memory_pages.into(), page_costs: schedule.memory_weights.clone().into(), existential_deposit, diff --git a/pallets/gear/src/mock.rs b/pallets/gear/src/mock.rs index 6ddddaa70ca..a8113a9342d 100644 --- a/pallets/gear/src/mock.rs +++ b/pallets/gear/src/mock.rs @@ -155,6 +155,7 @@ parameter_types! { pub RentCostPerBlock: Balance = 11; pub ResumeMinimalPeriod: BlockNumber = 100; pub ResumeSessionDuration: BlockNumber = 1_000; + pub const PerformanceMultiplier: u32 = 100; } thread_local! { @@ -217,6 +218,7 @@ impl pallet_gear::Config for Test { type WeightInfo = pallet_gear::weights::SubstrateWeight; type Schedule = DynamicSchedule; type OutgoingLimit = OutgoingLimit; + type PerformanceMultiplier = PerformanceMultiplier; type DebugInfo = (); type CodeStorage = GearProgram; type ProgramStorage = GearProgram; diff --git a/pallets/payment/src/mock.rs b/pallets/payment/src/mock.rs index a511c7c92bc..414bef402ae 100644 --- a/pallets/payment/src/mock.rs +++ b/pallets/payment/src/mock.rs @@ -167,6 +167,7 @@ impl pallet_transaction_payment::Config for Test { parameter_types! { pub const BlockGasLimit: u64 = 500_000; pub const OutgoingLimit: u32 = 1024; + pub const PerformanceMultiplier: u32 = 100; pub GearSchedule: pallet_gear::Schedule = >::default(); pub RentFreePeriod: BlockNumber = 1_000; pub RentCostPerBlock: Balance = 11; @@ -188,6 +189,7 @@ impl pallet_gear::Config for Test { type WeightInfo = (); type Schedule = GearSchedule; type OutgoingLimit = OutgoingLimit; + type PerformanceMultiplier = PerformanceMultiplier; type DebugInfo = (); type CodeStorage = GearProgram; type ProgramStorage = GearProgram; diff --git a/runtime/gear/src/lib.rs b/runtime/gear/src/lib.rs index 9bedffb36e0..4a6b5a2dbb5 100644 --- a/runtime/gear/src/lib.rs +++ b/runtime/gear/src/lib.rs @@ -450,6 +450,8 @@ parameter_types! { pub const OutgoingLimit: u32 = 1024; pub const MailboxThreshold: u64 = 3000; + + pub const PerformanceMultiplier: u32 = 100; } parameter_types! { @@ -470,6 +472,7 @@ impl pallet_gear::Config for Runtime { type WeightInfo = weights::pallet_gear::SubstrateWeight; type Schedule = Schedule; type OutgoingLimit = OutgoingLimit; + type PerformanceMultiplier = PerformanceMultiplier; type DebugInfo = DebugInfo; type CodeStorage = GearProgram; type ProgramStorage = GearProgram; diff --git a/runtime/vara/src/lib.rs b/runtime/vara/src/lib.rs index c15660bd521..fadaac51377 100644 --- a/runtime/vara/src/lib.rs +++ b/runtime/vara/src/lib.rs @@ -954,6 +954,8 @@ parameter_types! { pub const OutgoingLimit: u32 = 1024; pub const MailboxThreshold: u64 = 3000; + + pub const PerformanceMultiplier: u32 = 100; } parameter_types! { @@ -974,6 +976,7 @@ impl pallet_gear::Config for Runtime { type WeightInfo = weights::pallet_gear::SubstrateWeight; type Schedule = Schedule; type OutgoingLimit = OutgoingLimit; + type PerformanceMultiplier = PerformanceMultiplier; type DebugInfo = DebugInfo; type CodeStorage = GearProgram; type ProgramStorage = GearProgram; From 55ee00d32a89541eb0fdb6e3969720fe231d9b1b Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Tue, 3 Oct 2023 11:23:37 -0500 Subject: [PATCH 4/8] chore(runtime): update weights (#3377) Co-authored-by: tltsutltsu Co-authored-by: Elijah <83283675+tltsutltsu@users.noreply.github.com> Co-authored-by: Ilya Kalitov --- pallets/gear/src/weights.rs | 3476 +++++++++-------- runtime/gear/src/tests.rs | 2 +- runtime/gear/src/weights/frame_system.rs | 94 +- runtime/gear/src/weights/pallet_balances.rs | 62 +- runtime/gear/src/weights/pallet_gear.rs | 3474 ++++++++-------- .../gear/src/weights/pallet_gear_voucher.rs | 14 +- runtime/gear/src/weights/pallet_timestamp.rs | 22 +- runtime/gear/src/weights/pallet_utility.rs | 70 +- runtime/vara/src/tests.rs | 4 +- runtime/vara/src/weights/frame_system.rs | 82 +- runtime/vara/src/weights/pallet_balances.rs | 58 +- runtime/vara/src/weights/pallet_gear.rs | 3310 ++++++++-------- .../vara/src/weights/pallet_gear_voucher.rs | 10 +- runtime/vara/src/weights/pallet_timestamp.rs | 18 +- runtime/vara/src/weights/pallet_utility.rs | 66 +- 15 files changed, 5387 insertions(+), 5375 deletions(-) diff --git a/pallets/gear/src/weights.rs b/pallets/gear/src/weights.rs index c624ab416a4..477c7f3bd54 100644 --- a/pallets/gear/src/weights.rs +++ b/pallets/gear/src/weights.rs @@ -19,13 +19,13 @@ //! Autogenerated weights for pallet_gear //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-09-21, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-09-28, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` //! CPU: `Intel(R) Xeon(R) Platinum 8375C CPU @ 2.90GHz` -//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("vara-dev"), DB CACHE: 1024 +//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("gear-dev"), DB CACHE: 1024 // Executed Command: -// ./target/production/gear benchmark pallet --chain=vara-dev --steps=50 --repeat=20 --pallet=pallet_gear --extrinsic=* --execution=wasm --wasm-execution=compiled --heap-pages=4096 --output=./scripts/benchmarking/weights-output/pallet_gear.rs --template=.maintain/frame-weight-template.hbs +// ./target/production/gear benchmark pallet --chain=gear-dev --steps=50 --repeat=20 --pallet=pallet_gear --extrinsic=alloc,alloc_in_handle,alloc_per_page,claim_value,create_program,db_read_per_kb,db_write_per_kb,free,gr_block_height,gr_block_timestamp,gr_create_program,gr_create_program_per_kb,gr_create_program_wgas,gr_create_program_wgas_per_kb,gr_debug,gr_debug_per_kb,gr_gas_available,gr_message_id,gr_pay_program_rent,gr_program_id,gr_random,gr_read,gr_read_per_kb,gr_reply_code,gr_reply_deposit,gr_reply_per_kb,gr_reply_push,gr_reply_push_input,gr_reply_push_input_per_kb,gr_reply_push_per_kb,gr_reply_to,gr_reply_wgas_per_kb,gr_reservation_reply_commit_per_kb,gr_reservation_reply_per_kb,gr_reservation_send,gr_reservation_send_commit,gr_reservation_send_per_kb,gr_reserve_gas,gr_send,gr_send_commit,gr_send_commit_wgas,gr_send_init,gr_send_input,gr_send_input_wgas,gr_send_per_kb,gr_send_push,gr_send_push_input,gr_send_push_input_per_kb,gr_send_push_per_kb,gr_send_wgas,gr_send_wgas_per_kb,gr_signal_code,gr_signal_from,gr_size,gr_source,gr_system_reserve_gas,gr_unreserve_gas,gr_value,gr_value_available,gr_wake,initial_allocation,instantiate_module_per_kb,instr_br,instr_br_if,instr_br_table,instr_br_table_per_entry,instr_call,instr_call_const,instr_call_indirect,instr_call_indirect_per_param,instr_call_per_local,instr_global_get,instr_global_set,instr_i32add,instr_i32and,instr_i32clz,instr_i32ctz,instr_i32divs,instr_i32divu,instr_i32eq,instr_i32eqz,instr_i32extend16s,instr_i32extend8s,instr_i32ges,instr_i32geu,instr_i32gts,instr_i32gtu,instr_i32les,instr_i32leu,instr_i32load,instr_i32lts,instr_i32ltu,instr_i32mul,instr_i32ne,instr_i32or,instr_i32popcnt,instr_i32rems,instr_i32remu,instr_i32rotl,instr_i32rotr,instr_i32shl,instr_i32shrs,instr_i32shru,instr_i32store,instr_i32sub,instr_i32wrapi64,instr_i32xor,instr_i64add,instr_i64and,instr_i64clz,instr_i64ctz,instr_i64divs,instr_i64divu,instr_i64eq,instr_i64eqz,instr_i64extend16s,instr_i64extend32s,instr_i64extend8s,instr_i64extendsi32,instr_i64extendui32,instr_i64ges,instr_i64geu,instr_i64gts,instr_i64gtu,instr_i64les,instr_i64leu,instr_i64load,instr_i64lts,instr_i64ltu,instr_i64mul,instr_i64ne,instr_i64or,instr_i64popcnt,instr_i64rems,instr_i64remu,instr_i64rotl,instr_i64rotr,instr_i64shl,instr_i64shrs,instr_i64shru,instr_i64store,instr_i64sub,instr_i64xor,instr_if,instr_local_get,instr_local_set,instr_local_tee,instr_memory_current,instr_select,lazy_pages_host_func_read,lazy_pages_host_func_write,lazy_pages_host_func_write_after_read,lazy_pages_load_page_storage_data,lazy_pages_signal_read,lazy_pages_signal_write,lazy_pages_signal_write_after_read,mem_grow,pay_program_rent,reinstrument_per_kb,resume_session_commit,resume_session_init,resume_session_push,send_message,send_reply,tasks_pause_program,tasks_pause_program_uninited,tasks_remove_from_mailbox,tasks_remove_from_waitlist,tasks_remove_gas_reservation,tasks_remove_resume_session,tasks_send_dispatch,tasks_send_user_message,tasks_send_user_message_to_mailbox,tasks_wake_message,tasks_wake_message_no_wake,upload_code,upload_program --execution=wasm --wasm-execution=compiled --heap-pages=4096 --output=./scripts/benchmarking/weights-output/pallet_gear.rs --template=.maintain/frame-weight-template.hbs #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(unused_parens)] @@ -37,6 +37,19 @@ use sp_std::marker::PhantomData; /// Weight functions needed for pallet_gear. pub trait WeightInfo { + fn gr_reply(r: u32, ) -> Weight; + fn gr_reply_wgas(r: u32, ) -> Weight; + fn gr_reply_commit(r: u32, ) -> Weight; + fn gr_reply_commit_wgas(r: u32, ) -> Weight; + fn gr_reply_input(r: u32, ) -> Weight; + fn gr_reply_input_wgas(r: u32, ) -> Weight; + fn gr_reservation_reply(r: u32, ) -> Weight; + fn gr_reservation_reply_commit(r: u32, ) -> Weight; + fn gr_exit(r: u32, ) -> Weight; + fn gr_leave(r: u32, ) -> Weight; + fn gr_wait(r: u32, ) -> Weight; + fn gr_wait_for(r: u32, ) -> Weight; + fn gr_wait_up_to(r: u32, ) -> Weight; fn db_write_per_kb(c: u32, ) -> Weight; fn db_read_per_kb(c: u32, ) -> Weight; fn instantiate_module_per_kb(c: u32, ) -> Weight; @@ -86,19 +99,11 @@ pub trait WeightInfo { fn gr_reservation_send(r: u32, ) -> Weight; fn gr_reservation_send_per_kb(n: u32, ) -> Weight; fn gr_reservation_send_commit(r: u32, ) -> Weight; - fn gr_reply(r: u32, ) -> Weight; fn gr_reply_per_kb(n: u32, ) -> Weight; - fn gr_reply_wgas(r: u32, ) -> Weight; fn gr_reply_wgas_per_kb(n: u32, ) -> Weight; - fn gr_reply_commit(r: u32, ) -> Weight; - fn gr_reply_commit_wgas(r: u32, ) -> Weight; fn gr_reply_push(r: u32, ) -> Weight; fn gr_reply_push_per_kb(n: u32, ) -> Weight; - fn gr_reply_input(r: u32, ) -> Weight; - fn gr_reply_input_wgas(r: u32, ) -> Weight; - fn gr_reservation_reply(r: u32, ) -> Weight; fn gr_reservation_reply_per_kb(n: u32, ) -> Weight; - fn gr_reservation_reply_commit(r: u32, ) -> Weight; fn gr_reservation_reply_commit_per_kb(n: u32, ) -> Weight; fn gr_reply_to(r: u32, ) -> Weight; fn gr_signal_code(r: u32, ) -> Weight; @@ -110,11 +115,6 @@ pub trait WeightInfo { fn gr_debug(r: u32, ) -> Weight; fn gr_debug_per_kb(n: u32, ) -> Weight; fn gr_reply_code(r: u32, ) -> Weight; - fn gr_exit(r: u32, ) -> Weight; - fn gr_leave(r: u32, ) -> Weight; - fn gr_wait(r: u32, ) -> Weight; - fn gr_wait_for(r: u32, ) -> Weight; - fn gr_wait_up_to(r: u32, ) -> Weight; fn gr_wake(r: u32, ) -> Weight; fn gr_create_program(r: u32, ) -> Weight; fn gr_create_program_per_kb(p: u32, s: u32, ) -> Weight; @@ -237,6 +237,136 @@ pub trait WeightInfo { /// Weights for pallet_gear using the Gear node and recommended hardware. pub struct SubstrateWeight(PhantomData); impl WeightInfo for SubstrateWeight { + /// The range of component `r` is `[0, 1]`. + fn gr_reply(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 94_792_000 picoseconds. + Weight::from_parts(103_063_604, 0) + // Standard Error: 103_375 + .saturating_add(Weight::from_parts(18_929_072, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_reply_wgas(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 96_154_000 picoseconds. + Weight::from_parts(107_249_232, 0) + // Standard Error: 99_969 + .saturating_add(Weight::from_parts(19_062_846, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_reply_commit(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 98_701_000 picoseconds. + Weight::from_parts(109_478_842, 0) + // Standard Error: 104_175 + .saturating_add(Weight::from_parts(10_887_124, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_reply_commit_wgas(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 102_910_000 picoseconds. + Weight::from_parts(109_181_566, 0) + // Standard Error: 81_801 + .saturating_add(Weight::from_parts(12_077_508, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_reply_input(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 719_481_000 picoseconds. + Weight::from_parts(765_485_196, 0) + // Standard Error: 676_170 + .saturating_add(Weight::from_parts(17_778_524, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_reply_input_wgas(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 720_914_000 picoseconds. + Weight::from_parts(776_554_516, 0) + // Standard Error: 1_018_495 + .saturating_add(Weight::from_parts(38_306_948, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_reservation_reply(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 105_823_000 picoseconds. + Weight::from_parts(112_820_586, 0) + // Standard Error: 82_530 + .saturating_add(Weight::from_parts(14_370_506, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_reservation_reply_commit(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 102_415_000 picoseconds. + Weight::from_parts(110_005_402, 0) + // Standard Error: 87_514 + .saturating_add(Weight::from_parts(6_578_880, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_exit(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 96_593_000 picoseconds. + Weight::from_parts(104_873_732, 0) + // Standard Error: 2_095_391 + .saturating_add(Weight::from_parts(193_359_282, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_leave(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 93_619_000 picoseconds. + Weight::from_parts(99_623_244, 0) + // Standard Error: 1_945_328 + .saturating_add(Weight::from_parts(179_784_494, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_wait(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 92_936_000 picoseconds. + Weight::from_parts(100_139_452, 0) + // Standard Error: 1_753_555 + .saturating_add(Weight::from_parts(132_465_876, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_wait_for(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 93_955_000 picoseconds. + Weight::from_parts(100_650_632, 0) + // Standard Error: 2_018_388 + .saturating_add(Weight::from_parts(178_916_382, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_wait_up_to(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 95_467_000 picoseconds. + Weight::from_parts(102_532_790, 0) + // Standard Error: 2_065_180 + .saturating_add(Weight::from_parts(187_152_790, 0).saturating_mul(r.into())) + } fn allocation_cost() -> Weight { // To be changed with the proper value. T::DbWeight::get().writes(1) @@ -256,21 +386,21 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_023_000 picoseconds. - Weight::from_parts(1_051_000, 0) - // Standard Error: 912 - .saturating_add(Weight::from_parts(213_761, 0).saturating_mul(c.into())) + // Minimum execution time: 1_040_000 picoseconds. + Weight::from_parts(1_087_000, 0) + // Standard Error: 940 + .saturating_add(Weight::from_parts(251_751, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().writes(1_u64)) } /// The range of component `c` is `[0, 512]`. fn db_read_per_kb(c: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `146 + c * (1024 ±0)` - // Estimated: `3610 + c * (1024 ±0)` - // Minimum execution time: 3_252_000 picoseconds. - Weight::from_parts(3_416_000, 3610) - // Standard Error: 1_261 - .saturating_add(Weight::from_parts(689_572, 0).saturating_mul(c.into())) + // Measured: `79 + c * (1024 ±0)` + // Estimated: `3543 + c * (1024 ±0)` + // Minimum execution time: 3_333_000 picoseconds. + Weight::from_parts(3_463_000, 3543) + // Standard Error: 966 + .saturating_add(Weight::from_parts(678_430, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(Weight::from_parts(0, 1024).saturating_mul(c.into())) } @@ -279,35 +409,35 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 59_805_000 picoseconds. - Weight::from_parts(86_729_126, 0) - // Standard Error: 7_023 - .saturating_add(Weight::from_parts(2_475_519, 0).saturating_mul(c.into())) + // Minimum execution time: 61_586_000 picoseconds. + Weight::from_parts(95_956_778, 0) + // Standard Error: 5_472 + .saturating_add(Weight::from_parts(2_353_352, 0).saturating_mul(c.into())) } fn claim_value() -> Weight { // Proof Size summary in bytes: - // Measured: `1372` - // Estimated: `51905` - // Minimum execution time: 107_694_000 picoseconds. - Weight::from_parts(110_328_000, 51905) + // Measured: `1304` + // Estimated: `51293` + // Minimum execution time: 105_420_000 picoseconds. + Weight::from_parts(109_120_000, 51293) .saturating_add(T::DbWeight::get().reads(15_u64)) .saturating_add(T::DbWeight::get().writes(12_u64)) } fn pay_program_rent() -> Weight { // Proof Size summary in bytes: - // Measured: `992` - // Estimated: `21579` - // Minimum execution time: 55_980_000 picoseconds. - Weight::from_parts(56_766_000, 21579) + // Measured: `923` + // Estimated: `21372` + // Minimum execution time: 54_290_000 picoseconds. + Weight::from_parts(55_929_000, 21372) .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().writes(6_u64)) } fn resume_session_init() -> Weight { // Proof Size summary in bytes: - // Measured: `638` - // Estimated: `17486` - // Minimum execution time: 29_973_000 picoseconds. - Weight::from_parts(31_008_000, 17486) + // Measured: `570` + // Estimated: `17214` + // Minimum execution time: 29_539_000 picoseconds. + Weight::from_parts(30_515_000, 17214) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().writes(4_u64)) } @@ -316,22 +446,22 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `355` // Estimated: `7640` - // Minimum execution time: 8_054_000 picoseconds. - Weight::from_parts(8_342_000, 7640) - // Standard Error: 17_771 - .saturating_add(Weight::from_parts(13_335_661, 0).saturating_mul(c.into())) + // Minimum execution time: 8_426_000 picoseconds. + Weight::from_parts(5_984_423, 7640) + // Standard Error: 33_789 + .saturating_add(Weight::from_parts(13_895_151, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) } /// The range of component `c` is `[0, 2044]`. fn resume_session_commit(c: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `1593 + c * (16389 ±0)` - // Estimated: `43266 + c * (131112 ±0)` - // Minimum execution time: 72_178_000 picoseconds. - Weight::from_parts(73_341_000, 43266) - // Standard Error: 167_723 - .saturating_add(Weight::from_parts(54_442_045, 0).saturating_mul(c.into())) + // Measured: `1457 + c * (16389 ±0)` + // Estimated: `42178 + c * (131112 ±0)` + // Minimum execution time: 71_198_000 picoseconds. + Weight::from_parts(72_033_000, 42178) + // Standard Error: 159_543 + .saturating_add(Weight::from_parts(54_764_270, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(11_u64)) .saturating_add(T::DbWeight::get().writes(9_u64)) .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(c.into()))) @@ -340,24 +470,24 @@ impl WeightInfo for SubstrateWeight { /// The range of component `c` is `[0, 250]`. fn upload_code(c: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `113` - // Estimated: `5402` - // Minimum execution time: 78_662_000 picoseconds. - Weight::from_parts(42_066_175, 5402) - // Standard Error: 52_075 - .saturating_add(Weight::from_parts(60_249_549, 0).saturating_mul(c.into())) + // Measured: `46` + // Estimated: `5134` + // Minimum execution time: 77_259_000 picoseconds. + Weight::from_parts(52_968_469, 5134) + // Standard Error: 43_186 + .saturating_add(Weight::from_parts(59_988_588, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(4_u64)) } /// The range of component `s` is `[0, 4194304]`. fn create_program(s: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `1111` - // Estimated: `50600` - // Minimum execution time: 94_321_000 picoseconds. - Weight::from_parts(129_113_540, 50600) - // Standard Error: 1 - .saturating_add(Weight::from_parts(2_625, 0).saturating_mul(s.into())) + // Measured: `1043` + // Estimated: `49852` + // Minimum execution time: 96_734_000 picoseconds. + Weight::from_parts(136_364_170, 49852) + // Standard Error: 0 + .saturating_add(Weight::from_parts(2_592, 0).saturating_mul(s.into())) .saturating_add(T::DbWeight::get().reads(15_u64)) .saturating_add(T::DbWeight::get().writes(12_u64)) } @@ -365,72 +495,72 @@ impl WeightInfo for SubstrateWeight { /// The range of component `s` is `[0, 4194304]`. fn upload_program(c: u32, s: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `521` - // Estimated: `45152` - // Minimum execution time: 11_148_491_000 picoseconds. - Weight::from_parts(21_065_971, 45152) - // Standard Error: 173_883 - .saturating_add(Weight::from_parts(60_839_567, 0).saturating_mul(c.into())) - // Standard Error: 10 - .saturating_add(Weight::from_parts(2_652, 0).saturating_mul(s.into())) + // Measured: `453` + // Estimated: `44268` + // Minimum execution time: 11_047_048_000 picoseconds. + Weight::from_parts(211_012_859, 44268) + // Standard Error: 157_221 + .saturating_add(Weight::from_parts(59_860_835, 0).saturating_mul(c.into())) + // Standard Error: 9 + .saturating_add(Weight::from_parts(2_554, 0).saturating_mul(s.into())) .saturating_add(T::DbWeight::get().reads(15_u64)) .saturating_add(T::DbWeight::get().writes(16_u64)) } /// The range of component `p` is `[0, 2097152]`. fn send_message(p: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `531` - // Estimated: `31266` - // Minimum execution time: 73_302_000 picoseconds. - Weight::from_parts(47_279_667, 31266) + // Measured: `530` + // Estimated: `31259` + // Minimum execution time: 73_682_000 picoseconds. + Weight::from_parts(48_414_295, 31259) // Standard Error: 1 - .saturating_add(Weight::from_parts(1_055, 0).saturating_mul(p.into())) + .saturating_add(Weight::from_parts(1_040, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads(11_u64)) .saturating_add(T::DbWeight::get().writes(10_u64)) } /// The range of component `p` is `[0, 2097152]`. fn send_reply(p: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `1371` - // Estimated: `54435` - // Minimum execution time: 124_173_000 picoseconds. - Weight::from_parts(96_458_887, 54435) - // Standard Error: 2 - .saturating_add(Weight::from_parts(1_078, 0).saturating_mul(p.into())) + // Measured: `1303` + // Estimated: `53823` + // Minimum execution time: 122_837_000 picoseconds. + Weight::from_parts(97_209_014, 53823) + // Standard Error: 1 + .saturating_add(Weight::from_parts(1_068, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads(16_u64)) .saturating_add(T::DbWeight::get().writes(13_u64)) } /// The range of component `q` is `[1, 512]`. fn initial_allocation(_q: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `1893` - // Estimated: `114612` - // Minimum execution time: 365_983_000 picoseconds. - Weight::from_parts(387_416_952, 114612) - .saturating_add(T::DbWeight::get().reads(33_u64)) - .saturating_add(T::DbWeight::get().writes(26_u64)) + // Measured: `979` + // Estimated: `89393` + // Minimum execution time: 354_207_000 picoseconds. + Weight::from_parts(374_297_966, 89393) + .saturating_add(T::DbWeight::get().reads(31_u64)) + .saturating_add(T::DbWeight::get().writes(24_u64)) } /// The range of component `q` is `[0, 512]`. fn alloc_in_handle(q: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `1893` - // Estimated: `114612` - // Minimum execution time: 380_430_000 picoseconds. - Weight::from_parts(403_376_118, 114612) - // Standard Error: 2_451 - .saturating_add(Weight::from_parts(1_137, 0).saturating_mul(q.into())) - .saturating_add(T::DbWeight::get().reads(33_u64)) - .saturating_add(T::DbWeight::get().writes(26_u64)) + // Measured: `979` + // Estimated: `89133` + // Minimum execution time: 368_424_000 picoseconds. + Weight::from_parts(387_073_481, 89133) + // Standard Error: 1_472 + .saturating_add(Weight::from_parts(4_343, 0).saturating_mul(q.into())) + .saturating_add(T::DbWeight::get().reads(31_u64)) + .saturating_add(T::DbWeight::get().writes(24_u64)) } /// The range of component `c` is `[0, 512]`. fn reinstrument_per_kb(c: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `211 + c * (1075 ±0)` // Estimated: `3899 + c * (2150 ±0)` - // Minimum execution time: 58_080_000 picoseconds. - Weight::from_parts(58_601_000, 3899) - // Standard Error: 36_083 - .saturating_add(Weight::from_parts(58_395_643, 0).saturating_mul(c.into())) + // Minimum execution time: 58_209_000 picoseconds. + Weight::from_parts(58_498_000, 3899) + // Standard Error: 35_860 + .saturating_add(Weight::from_parts(58_109_594, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) .saturating_add(Weight::from_parts(0, 2150).saturating_mul(c.into())) @@ -440,638 +570,510 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 91_412_000 picoseconds. - Weight::from_parts(94_168_000, 0) - // Standard Error: 3_806_298 - .saturating_add(Weight::from_parts(673_774_453, 0).saturating_mul(r.into())) + // Minimum execution time: 92_645_000 picoseconds. + Weight::from_parts(95_763_000, 0) + // Standard Error: 3_691_564 + .saturating_add(Weight::from_parts(713_537_659, 0).saturating_mul(r.into())) } /// The range of component `p` is `[1, 512]`. fn alloc_per_page(p: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 452_549_000 picoseconds. - Weight::from_parts(398_963_700, 0) - // Standard Error: 7_042 - .saturating_add(Weight::from_parts(29_406_609, 0).saturating_mul(p.into())) + // Minimum execution time: 495_006_000 picoseconds. + Weight::from_parts(421_459_793, 0) + // Standard Error: 9_156 + .saturating_add(Weight::from_parts(29_070_022, 0).saturating_mul(p.into())) } /// The range of component `r` is `[0, 20]`. fn free(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 207_052_000 picoseconds. - Weight::from_parts(209_606_478, 0) - // Standard Error: 255_281 - .saturating_add(Weight::from_parts(62_959_531, 0).saturating_mul(r.into())) + // Minimum execution time: 219_414_000 picoseconds. + Weight::from_parts(206_118_379, 0) + // Standard Error: 320_555 + .saturating_add(Weight::from_parts(64_665_141, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 256]`. fn gr_reserve_gas(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 97_729_000 picoseconds. - Weight::from_parts(105_964_750, 0) - // Standard Error: 4_847 - .saturating_add(Weight::from_parts(2_433_966, 0).saturating_mul(r.into())) + // Minimum execution time: 96_871_000 picoseconds. + Weight::from_parts(104_318_392, 0) + // Standard Error: 4_224 + .saturating_add(Weight::from_parts(2_443_618, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 256]`. fn gr_unreserve_gas(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 175_010_000 picoseconds. - Weight::from_parts(229_153_209, 0) - // Standard Error: 17_116 - .saturating_add(Weight::from_parts(1_991_260, 0).saturating_mul(r.into())) + // Minimum execution time: 152_658_000 picoseconds. + Weight::from_parts(218_177_774, 0) + // Standard Error: 23_640 + .saturating_add(Weight::from_parts(2_186_094, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_system_reserve_gas(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 94_696_000 picoseconds. - Weight::from_parts(119_674_535, 0) - // Standard Error: 387_178 - .saturating_add(Weight::from_parts(98_102_856, 0).saturating_mul(r.into())) + // Minimum execution time: 97_532_000 picoseconds. + Weight::from_parts(112_244_990, 0) + // Standard Error: 370_435 + .saturating_add(Weight::from_parts(102_977_688, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_message_id(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 95_794_000 picoseconds. - Weight::from_parts(89_931_979, 0) - // Standard Error: 371_349 - .saturating_add(Weight::from_parts(86_524_059, 0).saturating_mul(r.into())) + // Minimum execution time: 95_116_000 picoseconds. + Weight::from_parts(85_754_801, 0) + // Standard Error: 322_936 + .saturating_add(Weight::from_parts(85_646_040, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_program_id(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 97_924_000 picoseconds. - Weight::from_parts(84_041_201, 0) - // Standard Error: 327_841 - .saturating_add(Weight::from_parts(95_483_315, 0).saturating_mul(r.into())) + // Minimum execution time: 97_226_000 picoseconds. + Weight::from_parts(96_400_189, 0) + // Standard Error: 308_975 + .saturating_add(Weight::from_parts(84_400_658, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_source(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 97_122_000 picoseconds. - Weight::from_parts(86_789_268, 0) - // Standard Error: 353_259 - .saturating_add(Weight::from_parts(85_698_317, 0).saturating_mul(r.into())) + // Minimum execution time: 96_667_000 picoseconds. + Weight::from_parts(95_221_535, 0) + // Standard Error: 320_528 + .saturating_add(Weight::from_parts(85_320_330, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_value(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 94_821_000 picoseconds. - Weight::from_parts(92_694_130, 0) - // Standard Error: 340_146 - .saturating_add(Weight::from_parts(84_623_945, 0).saturating_mul(r.into())) + // Minimum execution time: 96_400_000 picoseconds. + Weight::from_parts(83_830_464, 0) + // Standard Error: 333_677 + .saturating_add(Weight::from_parts(86_153_462, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_value_available(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 93_840_000 picoseconds. - Weight::from_parts(87_888_572, 0) - // Standard Error: 369_465 - .saturating_add(Weight::from_parts(85_638_902, 0).saturating_mul(r.into())) + // Minimum execution time: 98_322_000 picoseconds. + Weight::from_parts(88_780_011, 0) + // Standard Error: 365_736 + .saturating_add(Weight::from_parts(86_373_607, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_gas_available(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 98_597_000 picoseconds. - Weight::from_parts(86_642_386, 0) - // Standard Error: 362_257 - .saturating_add(Weight::from_parts(85_598_887, 0).saturating_mul(r.into())) + // Minimum execution time: 94_234_000 picoseconds. + Weight::from_parts(93_394_916, 0) + // Standard Error: 310_495 + .saturating_add(Weight::from_parts(85_678_300, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_size(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 94_546_000 picoseconds. - Weight::from_parts(91_466_289, 0) - // Standard Error: 344_423 - .saturating_add(Weight::from_parts(84_318_848, 0).saturating_mul(r.into())) + // Minimum execution time: 95_316_000 picoseconds. + Weight::from_parts(88_012_950, 0) + // Standard Error: 309_598 + .saturating_add(Weight::from_parts(85_813_369, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_read(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 578_036_000 picoseconds. - Weight::from_parts(696_140_951, 0) - // Standard Error: 559_498 - .saturating_add(Weight::from_parts(149_397_501, 0).saturating_mul(r.into())) + // Minimum execution time: 715_150_000 picoseconds. + Weight::from_parts(769_593_524, 0) + // Standard Error: 493_525 + .saturating_add(Weight::from_parts(140_935_499, 0).saturating_mul(r.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_read_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 723_788_000 picoseconds. - Weight::from_parts(740_225_000, 0) - // Standard Error: 52_895 - .saturating_add(Weight::from_parts(13_188_120, 0).saturating_mul(n.into())) + // Minimum execution time: 844_162_000 picoseconds. + Weight::from_parts(851_053_000, 0) + // Standard Error: 50_294 + .saturating_add(Weight::from_parts(13_068_816, 0).saturating_mul(n.into())) } /// The range of component `r` is `[0, 20]`. fn gr_block_height(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 99_012_000 picoseconds. - Weight::from_parts(88_269_135, 0) - // Standard Error: 296_136 - .saturating_add(Weight::from_parts(92_296_104, 0).saturating_mul(r.into())) + // Minimum execution time: 94_243_000 picoseconds. + Weight::from_parts(87_583_955, 0) + // Standard Error: 343_578 + .saturating_add(Weight::from_parts(84_267_053, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_block_timestamp(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 93_803_000 picoseconds. - Weight::from_parts(87_097_769, 0) - // Standard Error: 367_325 - .saturating_add(Weight::from_parts(84_987_043, 0).saturating_mul(r.into())) + // Minimum execution time: 95_559_000 picoseconds. + Weight::from_parts(92_460_596, 0) + // Standard Error: 340_344 + .saturating_add(Weight::from_parts(85_006_110, 0).saturating_mul(r.into())) } /// The range of component `n` is `[0, 20]`. fn gr_random(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 96_663_000 picoseconds. - Weight::from_parts(105_357_427, 0) - // Standard Error: 366_135 - .saturating_add(Weight::from_parts(172_109_201, 0).saturating_mul(n.into())) + // Minimum execution time: 95_023_000 picoseconds. + Weight::from_parts(113_045_564, 0) + // Standard Error: 350_542 + .saturating_add(Weight::from_parts(169_289_972, 0).saturating_mul(n.into())) } /// The range of component `r` is `[0, 20]`. fn gr_reply_deposit(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 99_210_000 picoseconds. - Weight::from_parts(102_217_000, 0) - // Standard Error: 4_527_119 - .saturating_add(Weight::from_parts(845_784_967, 0).saturating_mul(r.into())) + // Minimum execution time: 95_407_000 picoseconds. + Weight::from_parts(99_094_000, 0) + // Standard Error: 3_585_438 + .saturating_add(Weight::from_parts(776_362_449, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_send(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 96_579_000 picoseconds. - Weight::from_parts(162_452_429, 0) - // Standard Error: 416_836 - .saturating_add(Weight::from_parts(257_900_517, 0).saturating_mul(r.into())) + // Minimum execution time: 96_709_000 picoseconds. + Weight::from_parts(153_262_764, 0) + // Standard Error: 391_637 + .saturating_add(Weight::from_parts(256_389_022, 0).saturating_mul(r.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_send_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 353_526_000 picoseconds. - Weight::from_parts(358_025_000, 0) - // Standard Error: 61_984 - .saturating_add(Weight::from_parts(21_521_461, 0).saturating_mul(n.into())) + // Minimum execution time: 341_633_000 picoseconds. + Weight::from_parts(345_693_000, 0) + // Standard Error: 61_029 + .saturating_add(Weight::from_parts(21_298_548, 0).saturating_mul(n.into())) } /// The range of component `r` is `[0, 20]`. fn gr_send_wgas(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 94_822_000 picoseconds. - Weight::from_parts(168_431_611, 0) - // Standard Error: 378_696 - .saturating_add(Weight::from_parts(263_135_958, 0).saturating_mul(r.into())) + // Minimum execution time: 97_817_000 picoseconds. + Weight::from_parts(172_033_153, 0) + // Standard Error: 412_230 + .saturating_add(Weight::from_parts(260_826_119, 0).saturating_mul(r.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_send_wgas_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 351_828_000 picoseconds. - Weight::from_parts(355_382_000, 0) - // Standard Error: 60_589 - .saturating_add(Weight::from_parts(21_325_400, 0).saturating_mul(n.into())) + // Minimum execution time: 353_433_000 picoseconds. + Weight::from_parts(359_185_000, 0) + // Standard Error: 60_153 + .saturating_add(Weight::from_parts(21_224_949, 0).saturating_mul(n.into())) } /// The range of component `r` is `[0, 20]`. fn gr_send_input(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 569_384_000 picoseconds. - Weight::from_parts(638_474_730, 0) - // Standard Error: 425_903 - .saturating_add(Weight::from_parts(275_691_711, 0).saturating_mul(r.into())) + // Minimum execution time: 716_180_000 picoseconds. + Weight::from_parts(782_890_839, 0) + // Standard Error: 547_225 + .saturating_add(Weight::from_parts(273_570_636, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_send_input_wgas(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 573_053_000 picoseconds. - Weight::from_parts(640_078_802, 0) - // Standard Error: 475_389 - .saturating_add(Weight::from_parts(284_337_155, 0).saturating_mul(r.into())) + // Minimum execution time: 719_827_000 picoseconds. + Weight::from_parts(805_763_844, 0) + // Standard Error: 503_245 + .saturating_add(Weight::from_parts(278_200_889, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_send_init(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 98_223_000 picoseconds. - Weight::from_parts(85_732_985, 0) - // Standard Error: 336_308 - .saturating_add(Weight::from_parts(92_936_006, 0).saturating_mul(r.into())) + // Minimum execution time: 96_518_000 picoseconds. + Weight::from_parts(82_218_173, 0) + // Standard Error: 358_867 + .saturating_add(Weight::from_parts(92_408_337, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_send_push(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_822_621_000 picoseconds. - Weight::from_parts(1_951_955_018, 0) - // Standard Error: 339_415 - .saturating_add(Weight::from_parts(157_557_756, 0).saturating_mul(r.into())) + // Minimum execution time: 1_829_368_000 picoseconds. + Weight::from_parts(1_976_758_302, 0) + // Standard Error: 349_703 + .saturating_add(Weight::from_parts(163_038_781, 0).saturating_mul(r.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_send_push_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 314_296_000 picoseconds. - Weight::from_parts(317_522_000, 0) - // Standard Error: 61_360 - .saturating_add(Weight::from_parts(29_499_741, 0).saturating_mul(n.into())) + // Minimum execution time: 315_829_000 picoseconds. + Weight::from_parts(318_464_000, 0) + // Standard Error: 54_637 + .saturating_add(Weight::from_parts(31_280_567, 0).saturating_mul(n.into())) } /// The range of component `r` is `[0, 20]`. fn gr_send_commit(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_835_106_000 picoseconds. - Weight::from_parts(1_948_516_646, 0) - // Standard Error: 382_008 - .saturating_add(Weight::from_parts(214_812_508, 0).saturating_mul(r.into())) + // Minimum execution time: 1_818_937_000 picoseconds. + Weight::from_parts(1_941_969_566, 0) + // Standard Error: 412_244 + .saturating_add(Weight::from_parts(220_650_756, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_send_commit_wgas(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_827_496_000 picoseconds. - Weight::from_parts(1_949_190_773, 0) - // Standard Error: 340_175 - .saturating_add(Weight::from_parts(218_001_536, 0).saturating_mul(r.into())) + // Minimum execution time: 1_815_762_000 picoseconds. + Weight::from_parts(1_958_182_203, 0) + // Standard Error: 374_381 + .saturating_add(Weight::from_parts(229_106_637, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_reservation_send(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 264_306_000 picoseconds. - Weight::from_parts(363_536_651, 0) - // Standard Error: 467_914 - .saturating_add(Weight::from_parts(265_564_072, 0).saturating_mul(r.into())) + // Minimum execution time: 259_040_000 picoseconds. + Weight::from_parts(345_586_401, 0) + // Standard Error: 402_258 + .saturating_add(Weight::from_parts(274_866_021, 0).saturating_mul(r.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_reservation_send_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 523_150_000 picoseconds. - Weight::from_parts(535_842_000, 0) - // Standard Error: 65_412 - .saturating_add(Weight::from_parts(21_698_063, 0).saturating_mul(n.into())) + // Minimum execution time: 523_014_000 picoseconds. + Weight::from_parts(525_681_000, 0) + // Standard Error: 56_470 + .saturating_add(Weight::from_parts(21_443_571, 0).saturating_mul(n.into())) } /// The range of component `r` is `[0, 20]`. fn gr_reservation_send_commit(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_974_743_000 picoseconds. - Weight::from_parts(2_096_494_995, 0) - // Standard Error: 474_778 - .saturating_add(Weight::from_parts(232_524_299, 0).saturating_mul(r.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_reply(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 94_139_000 picoseconds. - Weight::from_parts(101_775_569, 0) - // Standard Error: 452_439 - .saturating_add(Weight::from_parts(16_839_430, 0).saturating_mul(r.into())) + // Minimum execution time: 1_967_181_000 picoseconds. + Weight::from_parts(2_076_078_781, 0) + // Standard Error: 455_370 + .saturating_add(Weight::from_parts(246_494_683, 0).saturating_mul(r.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_reply_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 112_050_000 picoseconds. - Weight::from_parts(102_205_366, 0) - // Standard Error: 1_008 - .saturating_add(Weight::from_parts(431_304, 0).saturating_mul(n.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_reply_wgas(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 93_528_000 picoseconds. - Weight::from_parts(99_748_422, 0) - // Standard Error: 396_992 - .saturating_add(Weight::from_parts(20_536_877, 0).saturating_mul(r.into())) + // Minimum execution time: 114_790_000 picoseconds. + Weight::from_parts(106_908_278, 0) + // Standard Error: 1_274 + .saturating_add(Weight::from_parts(430_785, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_reply_wgas_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 117_832_000 picoseconds. - Weight::from_parts(104_552_847, 0) - // Standard Error: 1_402 - .saturating_add(Weight::from_parts(432_018, 0).saturating_mul(n.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_reply_commit(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 93_325_000 picoseconds. - Weight::from_parts(101_074_097, 0) - // Standard Error: 454_790 - .saturating_add(Weight::from_parts(20_838_102, 0).saturating_mul(r.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_reply_commit_wgas(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 93_800_000 picoseconds. - Weight::from_parts(102_249_326, 0) - // Standard Error: 463_488 - .saturating_add(Weight::from_parts(15_991_473, 0).saturating_mul(r.into())) + // Minimum execution time: 115_541_000 picoseconds. + Weight::from_parts(101_956_035, 0) + // Standard Error: 3_603 + .saturating_add(Weight::from_parts(442_387, 0).saturating_mul(n.into())) } /// The range of component `r` is `[0, 20]`. fn gr_reply_push(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 93_153_000 picoseconds. - Weight::from_parts(121_452_989, 0) - // Standard Error: 390_540 - .saturating_add(Weight::from_parts(145_641_178, 0).saturating_mul(r.into())) + // Minimum execution time: 94_082_000 picoseconds. + Weight::from_parts(138_243_307, 0) + // Standard Error: 409_163 + .saturating_add(Weight::from_parts(154_758_505, 0).saturating_mul(r.into())) } /// The range of component `n` is `[0, 8192]`. fn gr_reply_push_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 115_529_000 picoseconds. - Weight::from_parts(120_413_000, 0) - // Standard Error: 3_105 - .saturating_add(Weight::from_parts(640_863, 0).saturating_mul(n.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_reply_input(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 566_859_000 picoseconds. - Weight::from_parts(631_111_316, 0) - // Standard Error: 7_012_228 - .saturating_add(Weight::from_parts(21_896_983, 0).saturating_mul(r.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_reply_input_wgas(_r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 565_382_000 picoseconds. - Weight::from_parts(613_048_008, 0) - } - /// The range of component `r` is `[0, 1]`. - fn gr_reservation_reply(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 104_401_000 picoseconds. - Weight::from_parts(112_651_320, 0) - // Standard Error: 438_590 - .saturating_add(Weight::from_parts(11_095_379, 0).saturating_mul(r.into())) + // Minimum execution time: 111_536_000 picoseconds. + Weight::from_parts(114_497_000, 0) + // Standard Error: 2_599 + .saturating_add(Weight::from_parts(656_994, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_reservation_reply_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 115_615_000 picoseconds. - Weight::from_parts(112_987_750, 0) - // Standard Error: 960 - .saturating_add(Weight::from_parts(423_774, 0).saturating_mul(n.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_reservation_reply_commit(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 105_056_000 picoseconds. - Weight::from_parts(113_735_922, 0) - // Standard Error: 466_586 - .saturating_add(Weight::from_parts(5_305_577, 0).saturating_mul(r.into())) + // Minimum execution time: 114_322_000 picoseconds. + Weight::from_parts(113_131_028, 0) + // Standard Error: 3_727 + .saturating_add(Weight::from_parts(436_168, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_reservation_reply_commit_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 113_897_000 picoseconds. - Weight::from_parts(112_616_408, 0) - // Standard Error: 1_722 - .saturating_add(Weight::from_parts(428_420, 0).saturating_mul(n.into())) + // Minimum execution time: 117_751_000 picoseconds. + Weight::from_parts(161_418_174, 0) + // Standard Error: 6_635 + .saturating_add(Weight::from_parts(405_229, 0).saturating_mul(n.into())) } /// The range of component `r` is `[0, 20]`. fn gr_reply_to(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 93_845_000 picoseconds. - Weight::from_parts(97_247_314, 0) - // Standard Error: 366_814 - .saturating_add(Weight::from_parts(85_900_587, 0).saturating_mul(r.into())) + // Minimum execution time: 93_524_000 picoseconds. + Weight::from_parts(89_332_032, 0) + // Standard Error: 294_566 + .saturating_add(Weight::from_parts(86_798_759, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_signal_code(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 98_960_000 picoseconds. - Weight::from_parts(96_741_705, 0) - // Standard Error: 331_442 - .saturating_add(Weight::from_parts(82_371_743, 0).saturating_mul(r.into())) + // Minimum execution time: 95_216_000 picoseconds. + Weight::from_parts(83_424_786, 0) + // Standard Error: 316_301 + .saturating_add(Weight::from_parts(84_774_296, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_signal_from(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 95_150_000 picoseconds. - Weight::from_parts(94_807_000, 0) - // Standard Error: 308_494 - .saturating_add(Weight::from_parts(85_723_479, 0).saturating_mul(r.into())) + // Minimum execution time: 96_461_000 picoseconds. + Weight::from_parts(97_636_300, 0) + // Standard Error: 278_297 + .saturating_add(Weight::from_parts(86_743_159, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_reply_push_input(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 565_388_000 picoseconds. - Weight::from_parts(606_358_854, 0) - // Standard Error: 430_766 - .saturating_add(Weight::from_parts(108_769_267, 0).saturating_mul(r.into())) + // Minimum execution time: 724_902_000 picoseconds. + Weight::from_parts(784_128_285, 0) + // Standard Error: 444_406 + .saturating_add(Weight::from_parts(105_223_470, 0).saturating_mul(r.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_reply_push_input_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 591_660_000 picoseconds. - Weight::from_parts(597_035_528, 0) - // Standard Error: 2_641 - .saturating_add(Weight::from_parts(153_781, 0).saturating_mul(n.into())) + // Minimum execution time: 737_666_000 picoseconds. + Weight::from_parts(758_797_216, 0) + // Standard Error: 1_260 + .saturating_add(Weight::from_parts(154_837, 0).saturating_mul(n.into())) } /// The range of component `r` is `[0, 20]`. fn gr_send_push_input(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_317_147_000 picoseconds. - Weight::from_parts(2_514_940_964, 0) - // Standard Error: 546_319 - .saturating_add(Weight::from_parts(128_825_542, 0).saturating_mul(r.into())) + // Minimum execution time: 2_498_871_000 picoseconds. + Weight::from_parts(2_688_516_696, 0) + // Standard Error: 531_545 + .saturating_add(Weight::from_parts(131_060_314, 0).saturating_mul(r.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_send_push_input_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_560_344_000 picoseconds. - Weight::from_parts(2_512_409_449, 0) - // Standard Error: 15_466 - .saturating_add(Weight::from_parts(12_395_144, 0).saturating_mul(n.into())) + // Minimum execution time: 2_657_855_000 picoseconds. + Weight::from_parts(2_746_003_287, 0) + // Standard Error: 12_743 + .saturating_add(Weight::from_parts(13_716_214, 0).saturating_mul(n.into())) } /// The range of component `r` is `[0, 20]`. fn gr_debug(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 97_996_000 picoseconds. - Weight::from_parts(130_630_238, 0) - // Standard Error: 414_418 - .saturating_add(Weight::from_parts(114_735_577, 0).saturating_mul(r.into())) + // Minimum execution time: 96_990_000 picoseconds. + Weight::from_parts(110_812_744, 0) + // Standard Error: 347_035 + .saturating_add(Weight::from_parts(120_462_128, 0).saturating_mul(r.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_debug_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 157_513_000 picoseconds. - Weight::from_parts(160_584_000, 0) - // Standard Error: 57_227 - .saturating_add(Weight::from_parts(25_738_939, 0).saturating_mul(n.into())) + // Minimum execution time: 170_244_000 picoseconds. + Weight::from_parts(175_502_000, 0) + // Standard Error: 56_203 + .saturating_add(Weight::from_parts(25_870_902, 0).saturating_mul(n.into())) } /// The range of component `r` is `[0, 20]`. fn gr_reply_code(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 92_652_000 picoseconds. - Weight::from_parts(88_138_429, 0) - // Standard Error: 330_537 - .saturating_add(Weight::from_parts(83_235_234, 0).saturating_mul(r.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_exit(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 93_824_000 picoseconds. - Weight::from_parts(102_740_497, 0) - // Standard Error: 428_593 - .saturating_add(Weight::from_parts(23_682_102, 0).saturating_mul(r.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_leave(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 92_530_000 picoseconds. - Weight::from_parts(101_410_861, 0) - // Standard Error: 432_236 - .saturating_add(Weight::from_parts(12_196_938, 0).saturating_mul(r.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_wait(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 93_402_000 picoseconds. - Weight::from_parts(102_285_877, 0) - // Standard Error: 466_463 - .saturating_add(Weight::from_parts(13_156_522, 0).saturating_mul(r.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_wait_for(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 95_706_000 picoseconds. - Weight::from_parts(102_513_059, 0) - // Standard Error: 464_787 - .saturating_add(Weight::from_parts(13_986_540, 0).saturating_mul(r.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_wait_up_to(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 93_057_000 picoseconds. - Weight::from_parts(99_083_869, 0) - // Standard Error: 378_747 - .saturating_add(Weight::from_parts(12_230_330, 0).saturating_mul(r.into())) + // Minimum execution time: 97_676_000 picoseconds. + Weight::from_parts(91_226_383, 0) + // Standard Error: 320_296 + .saturating_add(Weight::from_parts(82_761_490, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_wake(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 177_947_000 picoseconds. - Weight::from_parts(226_692_243, 0) - // Standard Error: 265_725 - .saturating_add(Weight::from_parts(156_938_838, 0).saturating_mul(r.into())) + // Minimum execution time: 149_319_000 picoseconds. + Weight::from_parts(230_971_562, 0) + // Standard Error: 338_138 + .saturating_add(Weight::from_parts(157_262_608, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_create_program(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 107_346_000 picoseconds. - Weight::from_parts(160_631_540, 0) - // Standard Error: 352_753 - .saturating_add(Weight::from_parts(338_685_448, 0).saturating_mul(r.into())) + // Minimum execution time: 108_167_000 picoseconds. + Weight::from_parts(178_994_489, 0) + // Standard Error: 404_012 + .saturating_add(Weight::from_parts(348_487_075, 0).saturating_mul(r.into())) } /// The range of component `p` is `[0, 2048]`. /// The range of component `s` is `[1, 2048]`. @@ -1079,22 +1081,22 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 44_754_074_000 picoseconds. - Weight::from_parts(44_833_050_000, 0) - // Standard Error: 269_308 - .saturating_add(Weight::from_parts(7_629_892, 0).saturating_mul(p.into())) - // Standard Error: 269_294 - .saturating_add(Weight::from_parts(179_148_245, 0).saturating_mul(s.into())) + // Minimum execution time: 43_645_119_000 picoseconds. + Weight::from_parts(43_811_648_000, 0) + // Standard Error: 262_276 + .saturating_add(Weight::from_parts(7_776_587, 0).saturating_mul(p.into())) + // Standard Error: 262_263 + .saturating_add(Weight::from_parts(178_958_075, 0).saturating_mul(s.into())) } /// The range of component `r` is `[0, 20]`. fn gr_create_program_wgas(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 108_278_000 picoseconds. - Weight::from_parts(161_208_126, 0) - // Standard Error: 368_644 - .saturating_add(Weight::from_parts(346_324_329, 0).saturating_mul(r.into())) + // Minimum execution time: 104_639_000 picoseconds. + Weight::from_parts(169_517_206, 0) + // Standard Error: 363_225 + .saturating_add(Weight::from_parts(357_078_703, 0).saturating_mul(r.into())) } /// The range of component `p` is `[0, 2048]`. /// The range of component `s` is `[1, 2048]`. @@ -1102,32 +1104,32 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 44_266_209_000 picoseconds. - Weight::from_parts(44_559_345_000, 0) - // Standard Error: 270_420 - .saturating_add(Weight::from_parts(7_460_172, 0).saturating_mul(p.into())) - // Standard Error: 270_407 - .saturating_add(Weight::from_parts(179_211_260, 0).saturating_mul(s.into())) + // Minimum execution time: 46_491_851_000 picoseconds. + Weight::from_parts(46_603_783_000, 0) + // Standard Error: 280_431 + .saturating_add(Weight::from_parts(7_250_257, 0).saturating_mul(p.into())) + // Standard Error: 280_417 + .saturating_add(Weight::from_parts(177_722_888, 0).saturating_mul(s.into())) } /// The range of component `r` is `[0, 20]`. fn gr_pay_program_rent(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 94_889_000 picoseconds. - Weight::from_parts(115_310_524, 0) - // Standard Error: 34_049 - .saturating_add(Weight::from_parts(1_916_607, 0).saturating_mul(r.into())) + // Minimum execution time: 95_721_000 picoseconds. + Weight::from_parts(114_995_832, 0) + // Standard Error: 36_809 + .saturating_add(Weight::from_parts(1_873_016, 0).saturating_mul(r.into())) } /// The range of component `p` is `[0, 512]`. fn lazy_pages_signal_read(p: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `141` // Estimated: `1131 + p * (9900 ±0)` - // Minimum execution time: 97_825_000 picoseconds. - Weight::from_parts(251_440_245, 1131) - // Standard Error: 70_641 - .saturating_add(Weight::from_parts(15_652_952, 0).saturating_mul(p.into())) + // Minimum execution time: 97_655_000 picoseconds. + Weight::from_parts(138_058_498, 1131) + // Standard Error: 18_813 + .saturating_add(Weight::from_parts(16_311_194, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads((4_u64).saturating_mul(p.into()))) .saturating_add(Weight::from_parts(0, 9900).saturating_mul(p.into())) } @@ -1136,10 +1138,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `141` // Estimated: `1131 + p * (9900 ±0)` - // Minimum execution time: 96_761_000 picoseconds. - Weight::from_parts(100_398_000, 1131) - // Standard Error: 45_532 - .saturating_add(Weight::from_parts(39_790_625, 0).saturating_mul(p.into())) + // Minimum execution time: 96_083_000 picoseconds. + Weight::from_parts(98_597_000, 1131) + // Standard Error: 43_515 + .saturating_add(Weight::from_parts(42_632_421, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads((4_u64).saturating_mul(p.into()))) .saturating_add(Weight::from_parts(0, 9900).saturating_mul(p.into())) } @@ -1148,10 +1150,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `141` // Estimated: `5069931` - // Minimum execution time: 7_471_807_000 picoseconds. - Weight::from_parts(7_440_591_962, 5069931) - // Standard Error: 168_373 - .saturating_add(Weight::from_parts(40_244_359, 0).saturating_mul(p.into())) + // Minimum execution time: 8_196_422_000 picoseconds. + Weight::from_parts(8_474_214_520, 5069931) + // Standard Error: 71_564 + .saturating_add(Weight::from_parts(41_738_666, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads(2048_u64)) } /// The range of component `p` is `[0, 512]`. @@ -1159,10 +1161,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `1813 + p * (65580 ±0)` // Estimated: `1939 + p * (75482 ±0)` - // Minimum execution time: 97_303_000 picoseconds. - Weight::from_parts(98_185_000, 1939) - // Standard Error: 38_471 - .saturating_add(Weight::from_parts(55_016_921, 0).saturating_mul(p.into())) + // Minimum execution time: 93_446_000 picoseconds. + Weight::from_parts(96_664_000, 1939) + // Standard Error: 46_722 + .saturating_add(Weight::from_parts(55_567_620, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads((4_u64).saturating_mul(p.into()))) .saturating_add(Weight::from_parts(0, 75482).saturating_mul(p.into())) } @@ -1171,10 +1173,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `141` // Estimated: `1131 + p * (9900 ±0)` - // Minimum execution time: 102_497_000 picoseconds. - Weight::from_parts(104_932_685, 1131) - // Standard Error: 78_974 - .saturating_add(Weight::from_parts(39_257_150, 0).saturating_mul(p.into())) + // Minimum execution time: 106_137_000 picoseconds. + Weight::from_parts(107_751_954, 1131) + // Standard Error: 71_200 + .saturating_add(Weight::from_parts(41_236_505, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads((4_u64).saturating_mul(p.into()))) .saturating_add(Weight::from_parts(0, 9900).saturating_mul(p.into())) } @@ -1183,10 +1185,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `141` // Estimated: `1496 + p * (9883 ±2)` - // Minimum execution time: 612_308_000 picoseconds. - Weight::from_parts(642_079_999, 1496) - // Standard Error: 357_245 - .saturating_add(Weight::from_parts(46_518_860, 0).saturating_mul(p.into())) + // Minimum execution time: 758_237_000 picoseconds. + Weight::from_parts(760_351_083, 1496) + // Standard Error: 319_479 + .saturating_add(Weight::from_parts(53_277_303, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads((4_u64).saturating_mul(p.into()))) .saturating_add(Weight::from_parts(0, 9883).saturating_mul(p.into())) } @@ -1195,10 +1197,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `141` // Estimated: `317931` - // Minimum execution time: 1_068_248_000 picoseconds. - Weight::from_parts(1_080_741_205, 317931) - // Standard Error: 262_216 - .saturating_add(Weight::from_parts(50_047_907, 0).saturating_mul(p.into())) + // Minimum execution time: 1_299_071_000 picoseconds. + Weight::from_parts(1_320_542_278, 317931) + // Standard Error: 364_770 + .saturating_add(Weight::from_parts(53_225_083, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads(128_u64)) } /// The range of component `r` is `[0, 20]`. @@ -1206,303 +1208,303 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 3_099_000 picoseconds. - Weight::from_parts(6_340_084, 0) - // Standard Error: 180_257 - .saturating_add(Weight::from_parts(74_666_091, 0).saturating_mul(r.into())) + // Minimum execution time: 4_118_000 picoseconds. + Weight::from_parts(7_418_987, 0) + // Standard Error: 299_976 + .saturating_add(Weight::from_parts(77_036_564, 0).saturating_mul(r.into())) } /// The range of component `r` is `[50, 500]`. fn instr_i64load(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 4_391_547_000 picoseconds. - Weight::from_parts(4_140_785_425, 0) - // Standard Error: 89_369 - .saturating_add(Weight::from_parts(5_769_622, 0).saturating_mul(r.into())) + // Minimum execution time: 4_461_228_000 picoseconds. + Weight::from_parts(4_172_544_233, 0) + // Standard Error: 108_717 + .saturating_add(Weight::from_parts(5_492_504, 0).saturating_mul(r.into())) } /// The range of component `r` is `[50, 500]`. fn instr_i32load(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 4_386_802_000 picoseconds. - Weight::from_parts(4_243_536_456, 0) - // Standard Error: 95_210 - .saturating_add(Weight::from_parts(5_278_131, 0).saturating_mul(r.into())) + // Minimum execution time: 4_440_105_000 picoseconds. + Weight::from_parts(4_189_326_223, 0) + // Standard Error: 94_884 + .saturating_add(Weight::from_parts(5_283_060, 0).saturating_mul(r.into())) } /// The range of component `r` is `[50, 500]`. fn instr_i64store(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 11_072_272_000 picoseconds. - Weight::from_parts(11_558_306_225, 0) - // Standard Error: 165_659 - .saturating_add(Weight::from_parts(9_828_260, 0).saturating_mul(r.into())) + // Minimum execution time: 11_389_557_000 picoseconds. + Weight::from_parts(11_860_510_711, 0) + // Standard Error: 156_021 + .saturating_add(Weight::from_parts(9_199_358, 0).saturating_mul(r.into())) } /// The range of component `r` is `[50, 500]`. fn instr_i32store(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 10_285_071_000 picoseconds. - Weight::from_parts(11_137_621_942, 0) - // Standard Error: 147_513 - .saturating_add(Weight::from_parts(9_014_757, 0).saturating_mul(r.into())) + // Minimum execution time: 11_497_103_000 picoseconds. + Weight::from_parts(11_330_880_436, 0) + // Standard Error: 132_247 + .saturating_add(Weight::from_parts(10_016_516, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_select(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_285_000 picoseconds. - Weight::from_parts(2_410_000, 0) - // Standard Error: 7_624 - .saturating_add(Weight::from_parts(3_864_490, 0).saturating_mul(r.into())) + // Minimum execution time: 2_381_000 picoseconds. + Weight::from_parts(2_444_000, 0) + // Standard Error: 7_402 + .saturating_add(Weight::from_parts(3_876_295, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_if(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_342_000 picoseconds. - Weight::from_parts(2_433_000, 0) - // Standard Error: 6_413 - .saturating_add(Weight::from_parts(3_120_732, 0).saturating_mul(r.into())) + // Minimum execution time: 2_405_000 picoseconds. + Weight::from_parts(481_308, 0) + // Standard Error: 8_161 + .saturating_add(Weight::from_parts(3_159_957, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_br(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_301_000 picoseconds. - Weight::from_parts(3_591_730, 0) - // Standard Error: 1_106 - .saturating_add(Weight::from_parts(1_565_415, 0).saturating_mul(r.into())) + // Minimum execution time: 2_371_000 picoseconds. + Weight::from_parts(3_249_787, 0) + // Standard Error: 1_586 + .saturating_add(Weight::from_parts(1_582_965, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_br_if(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_306_000 picoseconds. - Weight::from_parts(2_461_000, 0) - // Standard Error: 7_711 - .saturating_add(Weight::from_parts(2_932_880, 0).saturating_mul(r.into())) + // Minimum execution time: 2_216_000 picoseconds. + Weight::from_parts(2_300_000, 0) + // Standard Error: 6_757 + .saturating_add(Weight::from_parts(2_971_649, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_br_table(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_358_000 picoseconds. - Weight::from_parts(2_144_801, 0) - // Standard Error: 22_082 - .saturating_add(Weight::from_parts(5_266_139, 0).saturating_mul(r.into())) + // Minimum execution time: 2_259_000 picoseconds. + Weight::from_parts(2_872_259, 0) + // Standard Error: 19_834 + .saturating_add(Weight::from_parts(5_176_111, 0).saturating_mul(r.into())) } /// The range of component `e` is `[1, 256]`. fn instr_br_table_per_entry(e: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 6_803_000 picoseconds. - Weight::from_parts(5_374_690, 0) - // Standard Error: 1_699 - .saturating_add(Weight::from_parts(171_193, 0).saturating_mul(e.into())) + // Minimum execution time: 6_999_000 picoseconds. + Weight::from_parts(6_015_140, 0) + // Standard Error: 1_903 + .saturating_add(Weight::from_parts(170_143, 0).saturating_mul(e.into())) } /// The range of component `r` is `[0, 50]`. fn instr_call_const(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_431_000 picoseconds. - Weight::from_parts(4_875_813, 0) - // Standard Error: 8_258 - .saturating_add(Weight::from_parts(2_629_733, 0).saturating_mul(r.into())) + // Minimum execution time: 2_308_000 picoseconds. + Weight::from_parts(5_881_148, 0) + // Standard Error: 9_069 + .saturating_add(Weight::from_parts(2_574_099, 0).saturating_mul(r.into())) } fn instr_i64const(r: u32, ) -> Weight { Weight::from_parts(0, 0) - .saturating_add(Weight::from_parts(2_629_733 - - 2_421_700, 0).saturating_mul(r.into())) + .saturating_add(Weight::from_parts(2_574_099 - + 2_423_093, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_call(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_403_000 picoseconds. - Weight::from_parts(5_140_243, 0) - // Standard Error: 13_164 - .saturating_add(Weight::from_parts(2_421_700, 0).saturating_mul(r.into())) + // Minimum execution time: 2_337_000 picoseconds. + Weight::from_parts(5_123_036, 0) + // Standard Error: 12_143 + .saturating_add(Weight::from_parts(2_423_093, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_call_indirect(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_669_000 picoseconds. - Weight::from_parts(22_369_265, 0) - // Standard Error: 28_577 - .saturating_add(Weight::from_parts(9_740_558, 0).saturating_mul(r.into())) + // Minimum execution time: 2_736_000 picoseconds. + Weight::from_parts(16_600_828, 0) + // Standard Error: 30_025 + .saturating_add(Weight::from_parts(10_214_913, 0).saturating_mul(r.into())) } /// The range of component `p` is `[0, 128]`. fn instr_call_indirect_per_param(p: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 12_277_000 picoseconds. - Weight::from_parts(3_596_853, 0) - // Standard Error: 5_869 - .saturating_add(Weight::from_parts(1_258_605, 0).saturating_mul(p.into())) + // Minimum execution time: 12_483_000 picoseconds. + Weight::from_parts(1_416_669, 0) + // Standard Error: 5_995 + .saturating_add(Weight::from_parts(1_336_453, 0).saturating_mul(p.into())) } /// The range of component `l` is `[0, 1024]`. fn instr_call_per_local(_l: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 5_391_000 picoseconds. - Weight::from_parts(5_778_137, 0) + // Minimum execution time: 5_497_000 picoseconds. + Weight::from_parts(5_981_231, 0) } /// The range of component `r` is `[0, 50]`. fn instr_local_get(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 4_835_000 picoseconds. - Weight::from_parts(6_065_483, 0) - // Standard Error: 3_006 - .saturating_add(Weight::from_parts(378_512, 0).saturating_mul(r.into())) + // Minimum execution time: 4_730_000 picoseconds. + Weight::from_parts(5_851_529, 0) + // Standard Error: 2_642 + .saturating_add(Weight::from_parts(392_869, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_local_set(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 4_722_000 picoseconds. - Weight::from_parts(3_902_309, 0) - // Standard Error: 5_742 - .saturating_add(Weight::from_parts(1_056_408, 0).saturating_mul(r.into())) + // Minimum execution time: 4_837_000 picoseconds. + Weight::from_parts(4_473_635, 0) + // Standard Error: 5_210 + .saturating_add(Weight::from_parts(1_003_312, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_local_tee(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 4_888_000 picoseconds. - Weight::from_parts(4_512_058, 0) - // Standard Error: 6_410 - .saturating_add(Weight::from_parts(1_001_510, 0).saturating_mul(r.into())) + // Minimum execution time: 4_802_000 picoseconds. + Weight::from_parts(2_153_776, 0) + // Standard Error: 11_517 + .saturating_add(Weight::from_parts(1_186_032, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_global_get(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 6_413_000 picoseconds. - Weight::from_parts(2_704_134, 0) - // Standard Error: 7_244 - .saturating_add(Weight::from_parts(804_200, 0).saturating_mul(r.into())) + // Minimum execution time: 6_375_000 picoseconds. + Weight::from_parts(3_754_449, 0) + // Standard Error: 5_686 + .saturating_add(Weight::from_parts(763_597, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_global_set(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 6_516_000 picoseconds. - Weight::from_parts(1_028_752, 0) - // Standard Error: 8_792 - .saturating_add(Weight::from_parts(1_494_630, 0).saturating_mul(r.into())) + // Minimum execution time: 6_475_000 picoseconds. + Weight::from_parts(266_670, 0) + // Standard Error: 10_193 + .saturating_add(Weight::from_parts(1_552_777, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_memory_current(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 5_560_000 picoseconds. - Weight::from_parts(1_126_442, 0) - // Standard Error: 14_476 - .saturating_add(Weight::from_parts(7_240_597, 0).saturating_mul(r.into())) + // Minimum execution time: 6_887_000 picoseconds. + Weight::from_parts(4_333_544, 0) + // Standard Error: 10_173 + .saturating_add(Weight::from_parts(6_952_830, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64clz(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_299_000 picoseconds. - Weight::from_parts(2_449_000, 0) - // Standard Error: 7_416 - .saturating_add(Weight::from_parts(3_344_387, 0).saturating_mul(r.into())) + // Minimum execution time: 2_267_000 picoseconds. + Weight::from_parts(2_351_000, 0) + // Standard Error: 5_280 + .saturating_add(Weight::from_parts(3_360_413, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32clz(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_389_000 picoseconds. - Weight::from_parts(2_551_000, 0) - // Standard Error: 5_708 - .saturating_add(Weight::from_parts(3_133_430, 0).saturating_mul(r.into())) + // Minimum execution time: 2_283_000 picoseconds. + Weight::from_parts(2_357_000, 0) + // Standard Error: 4_452 + .saturating_add(Weight::from_parts(3_099_489, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64ctz(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_428_000 picoseconds. - Weight::from_parts(2_511_000, 0) - // Standard Error: 7_262 - .saturating_add(Weight::from_parts(3_192_675, 0).saturating_mul(r.into())) + // Minimum execution time: 2_328_000 picoseconds. + Weight::from_parts(2_417_000, 0) + // Standard Error: 5_054 + .saturating_add(Weight::from_parts(3_106_996, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32ctz(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_333_000 picoseconds. - Weight::from_parts(2_426_000, 0) - // Standard Error: 4_554 - .saturating_add(Weight::from_parts(2_683_293, 0).saturating_mul(r.into())) + // Minimum execution time: 2_230_000 picoseconds. + Weight::from_parts(2_296_000, 0) + // Standard Error: 3_924 + .saturating_add(Weight::from_parts(2_681_831, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64popcnt(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_334_000 picoseconds. - Weight::from_parts(2_385_000, 0) - // Standard Error: 4_686 - .saturating_add(Weight::from_parts(631_609, 0).saturating_mul(r.into())) + // Minimum execution time: 2_294_000 picoseconds. + Weight::from_parts(2_438_000, 0) + // Standard Error: 4_198 + .saturating_add(Weight::from_parts(603_106, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32popcnt(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_356_000 picoseconds. - Weight::from_parts(1_221_890, 0) - // Standard Error: 3_960 - .saturating_add(Weight::from_parts(452_047, 0).saturating_mul(r.into())) + // Minimum execution time: 2_257_000 picoseconds. + Weight::from_parts(2_121_941, 0) + // Standard Error: 3_525 + .saturating_add(Weight::from_parts(401_578, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64eqz(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_318_000 picoseconds. - Weight::from_parts(2_390_000, 0) - // Standard Error: 11_114 - .saturating_add(Weight::from_parts(1_916_122, 0).saturating_mul(r.into())) + // Minimum execution time: 2_224_000 picoseconds. + Weight::from_parts(2_291_000, 0) + // Standard Error: 9_436 + .saturating_add(Weight::from_parts(1_891_725, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32eqz(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_436_000 picoseconds. - Weight::from_parts(2_504_000, 0) - // Standard Error: 7_104 - .saturating_add(Weight::from_parts(1_156_958, 0).saturating_mul(r.into())) + // Minimum execution time: 2_273_000 picoseconds. + Weight::from_parts(2_417_000, 0) + // Standard Error: 8_255 + .saturating_add(Weight::from_parts(1_289_311, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32extend8s(r: u32, ) -> Weight { @@ -1510,631 +1512,631 @@ impl WeightInfo for SubstrateWeight { // Measured: `0` // Estimated: `0` // Minimum execution time: 2_276_000 picoseconds. - Weight::from_parts(1_708_596, 0) - // Standard Error: 2_843 - .saturating_add(Weight::from_parts(377_083, 0).saturating_mul(r.into())) + Weight::from_parts(1_306_236, 0) + // Standard Error: 5_275 + .saturating_add(Weight::from_parts(426_430, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32extend16s(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_386_000 picoseconds. - Weight::from_parts(1_424_415, 0) - // Standard Error: 3_599 - .saturating_add(Weight::from_parts(395_934, 0).saturating_mul(r.into())) + // Minimum execution time: 2_341_000 picoseconds. + Weight::from_parts(1_669_540, 0) + // Standard Error: 4_902 + .saturating_add(Weight::from_parts(405_099, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64extend8s(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_396_000 picoseconds. - Weight::from_parts(2_491_000, 0) - // Standard Error: 3_774 - .saturating_add(Weight::from_parts(516_281, 0).saturating_mul(r.into())) + // Minimum execution time: 2_244_000 picoseconds. + Weight::from_parts(2_317_000, 0) + // Standard Error: 3_916 + .saturating_add(Weight::from_parts(552_354, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64extend16s(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_308_000 picoseconds. - Weight::from_parts(548_192, 0) - // Standard Error: 4_583 - .saturating_add(Weight::from_parts(556_734, 0).saturating_mul(r.into())) + // Minimum execution time: 2_316_000 picoseconds. + Weight::from_parts(2_395_000, 0) + // Standard Error: 5_375 + .saturating_add(Weight::from_parts(589_608, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64extend32s(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_333_000 picoseconds. - Weight::from_parts(447_271, 0) - // Standard Error: 5_300 - .saturating_add(Weight::from_parts(535_915, 0).saturating_mul(r.into())) + // Minimum execution time: 2_258_000 picoseconds. + Weight::from_parts(98_911, 0) + // Standard Error: 7_257 + .saturating_add(Weight::from_parts(581_834, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64extendsi32(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_340_000 picoseconds. - Weight::from_parts(1_639_695, 0) - // Standard Error: 3_519 - .saturating_add(Weight::from_parts(368_523, 0).saturating_mul(r.into())) + // Minimum execution time: 2_293_000 picoseconds. + Weight::from_parts(1_730_402, 0) + // Standard Error: 4_194 + .saturating_add(Weight::from_parts(357_287, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64extendui32(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_305_000 picoseconds. - Weight::from_parts(2_843_474, 0) - // Standard Error: 1_950 - .saturating_add(Weight::from_parts(176_592, 0).saturating_mul(r.into())) + // Minimum execution time: 2_580_000 picoseconds. + Weight::from_parts(2_927_247, 0) + // Standard Error: 2_012 + .saturating_add(Weight::from_parts(181_106, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32wrapi64(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_351_000 picoseconds. - Weight::from_parts(2_894_613, 0) - // Standard Error: 2_024 - .saturating_add(Weight::from_parts(188_853, 0).saturating_mul(r.into())) + // Minimum execution time: 2_308_000 picoseconds. + Weight::from_parts(2_742_236, 0) + // Standard Error: 2_482 + .saturating_add(Weight::from_parts(187_830, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64eq(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_353_000 picoseconds. - Weight::from_parts(2_418_000, 0) - // Standard Error: 9_504 - .saturating_add(Weight::from_parts(1_936_605, 0).saturating_mul(r.into())) + // Minimum execution time: 2_324_000 picoseconds. + Weight::from_parts(2_385_000, 0) + // Standard Error: 9_154 + .saturating_add(Weight::from_parts(1_858_617, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32eq(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_291_000 picoseconds. - Weight::from_parts(2_364_000, 0) - // Standard Error: 8_346 - .saturating_add(Weight::from_parts(1_222_521, 0).saturating_mul(r.into())) + // Minimum execution time: 2_237_000 picoseconds. + Weight::from_parts(2_302_000, 0) + // Standard Error: 7_801 + .saturating_add(Weight::from_parts(1_226_411, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64ne(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_345_000 picoseconds. - Weight::from_parts(2_452_000, 0) - // Standard Error: 10_232 - .saturating_add(Weight::from_parts(1_883_867, 0).saturating_mul(r.into())) + // Minimum execution time: 2_265_000 picoseconds. + Weight::from_parts(2_358_000, 0) + // Standard Error: 9_102 + .saturating_add(Weight::from_parts(1_866_723, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32ne(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_323_000 picoseconds. - Weight::from_parts(2_387_000, 0) - // Standard Error: 7_581 - .saturating_add(Weight::from_parts(1_200_178, 0).saturating_mul(r.into())) + // Minimum execution time: 2_267_000 picoseconds. + Weight::from_parts(2_381_000, 0) + // Standard Error: 8_629 + .saturating_add(Weight::from_parts(1_209_968, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64lts(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_410_000 picoseconds. - Weight::from_parts(2_459_000, 0) - // Standard Error: 11_139 - .saturating_add(Weight::from_parts(1_877_766, 0).saturating_mul(r.into())) + // Minimum execution time: 2_274_000 picoseconds. + Weight::from_parts(2_330_000, 0) + // Standard Error: 9_193 + .saturating_add(Weight::from_parts(1_895_140, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32lts(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_273_000 picoseconds. - Weight::from_parts(2_387_000, 0) - // Standard Error: 8_083 - .saturating_add(Weight::from_parts(1_217_904, 0).saturating_mul(r.into())) + // Minimum execution time: 2_306_000 picoseconds. + Weight::from_parts(2_394_000, 0) + // Standard Error: 7_780 + .saturating_add(Weight::from_parts(1_209_776, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64ltu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_403_000 picoseconds. - Weight::from_parts(2_482_000, 0) - // Standard Error: 11_044 - .saturating_add(Weight::from_parts(1_956_302, 0).saturating_mul(r.into())) + // Minimum execution time: 2_273_000 picoseconds. + Weight::from_parts(2_395_000, 0) + // Standard Error: 8_868 + .saturating_add(Weight::from_parts(1_845_417, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32ltu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_353_000 picoseconds. - Weight::from_parts(2_420_000, 0) - // Standard Error: 7_870 - .saturating_add(Weight::from_parts(1_213_570, 0).saturating_mul(r.into())) + // Minimum execution time: 2_280_000 picoseconds. + Weight::from_parts(2_360_000, 0) + // Standard Error: 8_139 + .saturating_add(Weight::from_parts(1_208_611, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64gts(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_364_000 picoseconds. - Weight::from_parts(2_430_000, 0) - // Standard Error: 10_577 - .saturating_add(Weight::from_parts(1_968_043, 0).saturating_mul(r.into())) + // Minimum execution time: 2_299_000 picoseconds. + Weight::from_parts(2_335_000, 0) + // Standard Error: 8_008 + .saturating_add(Weight::from_parts(1_833_636, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32gts(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_328_000 picoseconds. - Weight::from_parts(2_442_000, 0) - // Standard Error: 7_838 - .saturating_add(Weight::from_parts(1_267_211, 0).saturating_mul(r.into())) + // Minimum execution time: 2_222_000 picoseconds. + Weight::from_parts(2_376_000, 0) + // Standard Error: 7_996 + .saturating_add(Weight::from_parts(1_224_203, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64gtu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_395_000 picoseconds. - Weight::from_parts(2_460_000, 0) - // Standard Error: 10_856 - .saturating_add(Weight::from_parts(1_910_357, 0).saturating_mul(r.into())) + // Minimum execution time: 2_371_000 picoseconds. + Weight::from_parts(2_421_000, 0) + // Standard Error: 9_119 + .saturating_add(Weight::from_parts(1_821_158, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32gtu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_343_000 picoseconds. - Weight::from_parts(2_409_000, 0) - // Standard Error: 5_786 - .saturating_add(Weight::from_parts(1_128_653, 0).saturating_mul(r.into())) + // Minimum execution time: 2_305_000 picoseconds. + Weight::from_parts(2_418_000, 0) + // Standard Error: 7_441 + .saturating_add(Weight::from_parts(1_186_995, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64les(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_318_000 picoseconds. - Weight::from_parts(2_433_000, 0) - // Standard Error: 10_344 - .saturating_add(Weight::from_parts(1_897_480, 0).saturating_mul(r.into())) + // Minimum execution time: 2_340_000 picoseconds. + Weight::from_parts(2_362_000, 0) + // Standard Error: 8_788 + .saturating_add(Weight::from_parts(1_811_701, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32les(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_355_000 picoseconds. - Weight::from_parts(2_460_000, 0) - // Standard Error: 6_963 - .saturating_add(Weight::from_parts(1_125_698, 0).saturating_mul(r.into())) + // Minimum execution time: 2_352_000 picoseconds. + Weight::from_parts(2_431_000, 0) + // Standard Error: 6_620 + .saturating_add(Weight::from_parts(1_171_906, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64leu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_356_000 picoseconds. - Weight::from_parts(2_447_000, 0) - // Standard Error: 8_285 - .saturating_add(Weight::from_parts(1_848_149, 0).saturating_mul(r.into())) + // Minimum execution time: 2_352_000 picoseconds. + Weight::from_parts(2_380_000, 0) + // Standard Error: 8_554 + .saturating_add(Weight::from_parts(1_821_955, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32leu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_327_000 picoseconds. - Weight::from_parts(2_394_000, 0) - // Standard Error: 7_282 - .saturating_add(Weight::from_parts(1_176_423, 0).saturating_mul(r.into())) + // Minimum execution time: 2_299_000 picoseconds. + Weight::from_parts(2_389_000, 0) + // Standard Error: 7_710 + .saturating_add(Weight::from_parts(1_188_722, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64ges(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_372_000 picoseconds. - Weight::from_parts(2_439_000, 0) - // Standard Error: 9_207 - .saturating_add(Weight::from_parts(1_837_009, 0).saturating_mul(r.into())) + // Minimum execution time: 2_325_000 picoseconds. + Weight::from_parts(2_387_000, 0) + // Standard Error: 10_150 + .saturating_add(Weight::from_parts(1_912_877, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32ges(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_368_000 picoseconds. - Weight::from_parts(2_427_000, 0) - // Standard Error: 8_320 - .saturating_add(Weight::from_parts(1_231_088, 0).saturating_mul(r.into())) + // Minimum execution time: 2_377_000 picoseconds. + Weight::from_parts(2_423_000, 0) + // Standard Error: 6_824 + .saturating_add(Weight::from_parts(1_181_831, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64geu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_373_000 picoseconds. - Weight::from_parts(2_461_000, 0) - // Standard Error: 9_499 - .saturating_add(Weight::from_parts(1_922_588, 0).saturating_mul(r.into())) + // Minimum execution time: 2_292_000 picoseconds. + Weight::from_parts(2_384_000, 0) + // Standard Error: 9_214 + .saturating_add(Weight::from_parts(1_842_825, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32geu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_387_000 picoseconds. - Weight::from_parts(2_455_000, 0) - // Standard Error: 7_681 - .saturating_add(Weight::from_parts(1_198_894, 0).saturating_mul(r.into())) + // Minimum execution time: 2_283_000 picoseconds. + Weight::from_parts(2_344_000, 0) + // Standard Error: 7_145 + .saturating_add(Weight::from_parts(1_216_207, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64add(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_308_000 picoseconds. - Weight::from_parts(2_389_000, 0) - // Standard Error: 7_797 - .saturating_add(Weight::from_parts(1_286_566, 0).saturating_mul(r.into())) + // Minimum execution time: 2_232_000 picoseconds. + Weight::from_parts(2_391_000, 0) + // Standard Error: 9_159 + .saturating_add(Weight::from_parts(1_360_135, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32add(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_329_000 picoseconds. - Weight::from_parts(2_389_000, 0) - // Standard Error: 4_968 - .saturating_add(Weight::from_parts(645_254, 0).saturating_mul(r.into())) + // Minimum execution time: 2_279_000 picoseconds. + Weight::from_parts(2_379_000, 0) + // Standard Error: 5_400 + .saturating_add(Weight::from_parts(704_012, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64sub(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_409_000 picoseconds. - Weight::from_parts(2_489_000, 0) - // Standard Error: 7_055 - .saturating_add(Weight::from_parts(1_232_084, 0).saturating_mul(r.into())) + // Minimum execution time: 2_355_000 picoseconds. + Weight::from_parts(2_402_000, 0) + // Standard Error: 8_632 + .saturating_add(Weight::from_parts(1_358_130, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32sub(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_371_000 picoseconds. - Weight::from_parts(2_420_000, 0) - // Standard Error: 4_348 - .saturating_add(Weight::from_parts(633_810, 0).saturating_mul(r.into())) + // Minimum execution time: 2_365_000 picoseconds. + Weight::from_parts(2_389_000, 0) + // Standard Error: 4_840 + .saturating_add(Weight::from_parts(658_882, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64mul(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_336_000 picoseconds. - Weight::from_parts(2_413_000, 0) - // Standard Error: 8_202 - .saturating_add(Weight::from_parts(1_777_425, 0).saturating_mul(r.into())) + // Minimum execution time: 2_209_000 picoseconds. + Weight::from_parts(2_324_000, 0) + // Standard Error: 8_679 + .saturating_add(Weight::from_parts(1_840_263, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32mul(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_314_000 picoseconds. - Weight::from_parts(2_369_000, 0) - // Standard Error: 6_935 - .saturating_add(Weight::from_parts(1_201_570, 0).saturating_mul(r.into())) + // Minimum execution time: 2_258_000 picoseconds. + Weight::from_parts(2_382_000, 0) + // Standard Error: 7_484 + .saturating_add(Weight::from_parts(1_255_185, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64divs(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_276_000 picoseconds. - Weight::from_parts(6_846_840, 0) - // Standard Error: 17_822 - .saturating_add(Weight::from_parts(2_268_370, 0).saturating_mul(r.into())) + // Minimum execution time: 2_369_000 picoseconds. + Weight::from_parts(6_412_885, 0) + // Standard Error: 22_130 + .saturating_add(Weight::from_parts(2_376_785, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32divs(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_394_000 picoseconds. - Weight::from_parts(4_704_336, 0) - // Standard Error: 10_960 - .saturating_add(Weight::from_parts(2_182_711, 0).saturating_mul(r.into())) + // Minimum execution time: 2_266_000 picoseconds. + Weight::from_parts(2_981_330, 0) + // Standard Error: 11_996 + .saturating_add(Weight::from_parts(2_322_763, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64divu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_375_000 picoseconds. - Weight::from_parts(1_968_824, 0) - // Standard Error: 15_899 - .saturating_add(Weight::from_parts(2_762_269, 0).saturating_mul(r.into())) + // Minimum execution time: 2_240_000 picoseconds. + Weight::from_parts(7_628_007, 0) + // Standard Error: 29_510 + .saturating_add(Weight::from_parts(2_483_957, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32divu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_335_000 picoseconds. - Weight::from_parts(1_450_000, 0) - // Standard Error: 13_496 - .saturating_add(Weight::from_parts(2_401_407, 0).saturating_mul(r.into())) + // Minimum execution time: 2_387_000 picoseconds. + Weight::from_parts(4_910_027, 0) + // Standard Error: 23_548 + .saturating_add(Weight::from_parts(2_233_487, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64rems(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_448_000 picoseconds. - Weight::from_parts(2_513_000, 0) - // Standard Error: 19_401 - .saturating_add(Weight::from_parts(9_309_211, 0).saturating_mul(r.into())) + // Minimum execution time: 2_297_000 picoseconds. + Weight::from_parts(16_240_633, 0) + // Standard Error: 67_100 + .saturating_add(Weight::from_parts(8_506_720, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32rems(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_273_000 picoseconds. - Weight::from_parts(1_738_370, 0) - // Standard Error: 42_672 - .saturating_add(Weight::from_parts(7_512_557, 0).saturating_mul(r.into())) + // Minimum execution time: 2_234_000 picoseconds. + Weight::from_parts(2_498_693, 0) + // Standard Error: 48_996 + .saturating_add(Weight::from_parts(7_513_162, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64remu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_371_000 picoseconds. - Weight::from_parts(2_215_088, 0) - // Standard Error: 15_445 - .saturating_add(Weight::from_parts(2_956_278, 0).saturating_mul(r.into())) + // Minimum execution time: 2_221_000 picoseconds. + Weight::from_parts(5_074_264, 0) + // Standard Error: 23_109 + .saturating_add(Weight::from_parts(2_727_269, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32remu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_409_000 picoseconds. - Weight::from_parts(217_500, 0) - // Standard Error: 7_904 - .saturating_add(Weight::from_parts(2_576_151, 0).saturating_mul(r.into())) + // Minimum execution time: 2_283_000 picoseconds. + Weight::from_parts(2_057_554, 0) + // Standard Error: 15_404 + .saturating_add(Weight::from_parts(2_428_553, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64and(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_456_000 picoseconds. - Weight::from_parts(2_503_000, 0) - // Standard Error: 7_920 - .saturating_add(Weight::from_parts(1_321_543, 0).saturating_mul(r.into())) + // Minimum execution time: 2_250_000 picoseconds. + Weight::from_parts(2_359_000, 0) + // Standard Error: 8_133 + .saturating_add(Weight::from_parts(1_333_125, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32and(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_346_000 picoseconds. - Weight::from_parts(2_479_000, 0) - // Standard Error: 4_711 - .saturating_add(Weight::from_parts(689_892, 0).saturating_mul(r.into())) + // Minimum execution time: 2_251_000 picoseconds. + Weight::from_parts(2_372_000, 0) + // Standard Error: 4_205 + .saturating_add(Weight::from_parts(671_074, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64or(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_339_000 picoseconds. - Weight::from_parts(2_427_000, 0) - // Standard Error: 8_029 - .saturating_add(Weight::from_parts(1_256_838, 0).saturating_mul(r.into())) + // Minimum execution time: 2_257_000 picoseconds. + Weight::from_parts(2_323_000, 0) + // Standard Error: 7_098 + .saturating_add(Weight::from_parts(1_323_703, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32or(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_334_000 picoseconds. - Weight::from_parts(2_480_000, 0) - // Standard Error: 3_812 - .saturating_add(Weight::from_parts(607_420, 0).saturating_mul(r.into())) + // Minimum execution time: 2_247_000 picoseconds. + Weight::from_parts(2_372_000, 0) + // Standard Error: 6_649 + .saturating_add(Weight::from_parts(695_117, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64xor(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_328_000 picoseconds. - Weight::from_parts(2_392_000, 0) - // Standard Error: 7_362 - .saturating_add(Weight::from_parts(1_248_739, 0).saturating_mul(r.into())) + // Minimum execution time: 2_293_000 picoseconds. + Weight::from_parts(2_347_000, 0) + // Standard Error: 7_359 + .saturating_add(Weight::from_parts(1_355_885, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32xor(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_419_000 picoseconds. - Weight::from_parts(2_465_000, 0) - // Standard Error: 4_304 - .saturating_add(Weight::from_parts(604_813, 0).saturating_mul(r.into())) + // Minimum execution time: 2_239_000 picoseconds. + Weight::from_parts(2_335_000, 0) + // Standard Error: 4_076 + .saturating_add(Weight::from_parts(658_834, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64shl(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_298_000 picoseconds. - Weight::from_parts(2_433_000, 0) - // Standard Error: 8_043 - .saturating_add(Weight::from_parts(1_073_194, 0).saturating_mul(r.into())) + // Minimum execution time: 2_376_000 picoseconds. + Weight::from_parts(2_444_000, 0) + // Standard Error: 6_850 + .saturating_add(Weight::from_parts(1_191_253, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32shl(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_427_000 picoseconds. - Weight::from_parts(2_511_000, 0) - // Standard Error: 4_969 - .saturating_add(Weight::from_parts(594_802, 0).saturating_mul(r.into())) + // Minimum execution time: 2_240_000 picoseconds. + Weight::from_parts(2_310_000, 0) + // Standard Error: 4_398 + .saturating_add(Weight::from_parts(597_162, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64shrs(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_312_000 picoseconds. - Weight::from_parts(2_399_000, 0) - // Standard Error: 7_093 - .saturating_add(Weight::from_parts(1_110_114, 0).saturating_mul(r.into())) + // Minimum execution time: 2_338_000 picoseconds. + Weight::from_parts(2_421_000, 0) + // Standard Error: 8_320 + .saturating_add(Weight::from_parts(1_163_071, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32shrs(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_331_000 picoseconds. - Weight::from_parts(2_433_000, 0) - // Standard Error: 4_140 - .saturating_add(Weight::from_parts(600_354, 0).saturating_mul(r.into())) + // Minimum execution time: 2_376_000 picoseconds. + Weight::from_parts(2_464_000, 0) + // Standard Error: 5_750 + .saturating_add(Weight::from_parts(613_283, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64shru(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_300_000 picoseconds. - Weight::from_parts(2_419_000, 0) - // Standard Error: 7_150 - .saturating_add(Weight::from_parts(1_154_649, 0).saturating_mul(r.into())) + // Minimum execution time: 2_338_000 picoseconds. + Weight::from_parts(2_378_000, 0) + // Standard Error: 7_893 + .saturating_add(Weight::from_parts(1_161_655, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32shru(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_356_000 picoseconds. - Weight::from_parts(2_423_000, 0) - // Standard Error: 5_067 - .saturating_add(Weight::from_parts(594_487, 0).saturating_mul(r.into())) + // Minimum execution time: 2_260_000 picoseconds. + Weight::from_parts(2_351_000, 0) + // Standard Error: 3_972 + .saturating_add(Weight::from_parts(605_013, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64rotl(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_339_000 picoseconds. - Weight::from_parts(2_406_000, 0) - // Standard Error: 5_674 - .saturating_add(Weight::from_parts(1_051_819, 0).saturating_mul(r.into())) + // Minimum execution time: 2_324_000 picoseconds. + Weight::from_parts(2_375_000, 0) + // Standard Error: 7_329 + .saturating_add(Weight::from_parts(1_108_542, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32rotl(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_383_000 picoseconds. - Weight::from_parts(114_723, 0) - // Standard Error: 5_881 - .saturating_add(Weight::from_parts(646_798, 0).saturating_mul(r.into())) + // Minimum execution time: 2_342_000 picoseconds. + Weight::from_parts(2_465_000, 0) + // Standard Error: 5_553 + .saturating_add(Weight::from_parts(617_389, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64rotr(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_292_000 picoseconds. - Weight::from_parts(2_422_000, 0) - // Standard Error: 6_697 - .saturating_add(Weight::from_parts(1_053_580, 0).saturating_mul(r.into())) + // Minimum execution time: 2_260_000 picoseconds. + Weight::from_parts(2_419_000, 0) + // Standard Error: 8_448 + .saturating_add(Weight::from_parts(1_105_239, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32rotr(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_325_000 picoseconds. - Weight::from_parts(206_699, 0) - // Standard Error: 5_851 - .saturating_add(Weight::from_parts(639_333, 0).saturating_mul(r.into())) + // Minimum execution time: 2_255_000 picoseconds. + Weight::from_parts(2_321_000, 0) + // Standard Error: 5_862 + .saturating_add(Weight::from_parts(626_497, 0).saturating_mul(r.into())) } fn tasks_remove_resume_session() -> Weight { // Proof Size summary in bytes: // Measured: `352` // Estimated: `4169` - // Minimum execution time: 5_698_000 picoseconds. - Weight::from_parts(5_953_000, 4169) + // Minimum execution time: 5_780_000 picoseconds. + Weight::from_parts(6_083_000, 4169) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) } fn tasks_remove_gas_reservation() -> Weight { // Proof Size summary in bytes: - // Measured: `1003` - // Estimated: `23637` - // Minimum execution time: 61_615_000 picoseconds. - Weight::from_parts(64_309_000, 23637) + // Measured: `1039` + // Estimated: `23781` + // Minimum execution time: 62_100_000 picoseconds. + Weight::from_parts(64_771_000, 23781) .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().writes(6_u64)) } fn tasks_send_user_message_to_mailbox() -> Weight { // Proof Size summary in bytes: - // Measured: `784` - // Estimated: `21534` - // Minimum execution time: 43_449_000 picoseconds. - Weight::from_parts(44_990_000, 21534) + // Measured: `820` + // Estimated: `21750` + // Minimum execution time: 47_415_000 picoseconds. + Weight::from_parts(48_906_000, 21750) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().writes(5_u64)) } fn tasks_send_user_message() -> Weight { // Proof Size summary in bytes: - // Measured: `906` - // Estimated: `33891` - // Minimum execution time: 75_764_000 picoseconds. - Weight::from_parts(77_875_000, 33891) + // Measured: `942` + // Estimated: `34143` + // Minimum execution time: 76_882_000 picoseconds. + Weight::from_parts(79_728_000, 34143) .saturating_add(T::DbWeight::get().reads(11_u64)) .saturating_add(T::DbWeight::get().writes(10_u64)) } fn tasks_send_dispatch() -> Weight { // Proof Size summary in bytes: - // Measured: `591` - // Estimated: `19885` - // Minimum execution time: 31_362_000 picoseconds. - Weight::from_parts(32_425_000, 19885) + // Measured: `627` + // Estimated: `20101` + // Minimum execution time: 32_342_000 picoseconds. + Weight::from_parts(33_851_000, 20101) .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().writes(6_u64)) } fn tasks_wake_message() -> Weight { // Proof Size summary in bytes: - // Measured: `872` - // Estimated: `25908` - // Minimum execution time: 45_023_000 picoseconds. - Weight::from_parts(46_479_000, 25908) + // Measured: `908` + // Estimated: `26160` + // Minimum execution time: 50_697_000 picoseconds. + Weight::from_parts(53_632_000, 26160) .saturating_add(T::DbWeight::get().reads(8_u64)) .saturating_add(T::DbWeight::get().writes(6_u64)) } @@ -2142,37 +2144,37 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `80` // Estimated: `3545` - // Minimum execution time: 3_365_000 picoseconds. - Weight::from_parts(3_639_000, 3545) + // Minimum execution time: 3_467_000 picoseconds. + Weight::from_parts(3_690_000, 3545) .saturating_add(T::DbWeight::get().reads(1_u64)) } fn tasks_remove_from_waitlist() -> Weight { // Proof Size summary in bytes: - // Measured: `1522` - // Estimated: `57192` - // Minimum execution time: 114_023_000 picoseconds. - Weight::from_parts(117_157_000, 57192) + // Measured: `1558` + // Estimated: `57552` + // Minimum execution time: 111_822_000 picoseconds. + Weight::from_parts(115_245_000, 57552) .saturating_add(T::DbWeight::get().reads(16_u64)) .saturating_add(T::DbWeight::get().writes(13_u64)) } fn tasks_remove_from_mailbox() -> Weight { // Proof Size summary in bytes: - // Measured: `1228` - // Estimated: `46026` - // Minimum execution time: 90_320_000 picoseconds. - Weight::from_parts(93_096_000, 46026) + // Measured: `1264` + // Estimated: `46350` + // Minimum execution time: 92_407_000 picoseconds. + Weight::from_parts(95_840_000, 46350) .saturating_add(T::DbWeight::get().reads(14_u64)) .saturating_add(T::DbWeight::get().writes(13_u64)) } /// The range of component `c` is `[0, 2044]`. fn tasks_pause_program(c: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `2200 + c * (16400 ±0)` - // Estimated: `19363 + c * (84480 ±0)` - // Minimum execution time: 28_326_000 picoseconds. - Weight::from_parts(28_612_000, 19363) - // Standard Error: 73_191 - .saturating_add(Weight::from_parts(39_403_570, 0).saturating_mul(c.into())) + // Measured: `2236 + c * (16400 ±0)` + // Estimated: `19543 + c * (84480 ±0)` + // Minimum execution time: 29_880_000 picoseconds. + Weight::from_parts(30_555_000, 19543) + // Standard Error: 65_806 + .saturating_add(Weight::from_parts(39_128_234, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(4_u64)) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(c.into()))) .saturating_add(T::DbWeight::get().writes(2_u64)) @@ -2182,12 +2184,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `c` is `[0, 2044]`. fn tasks_pause_program_uninited(c: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `3025 + c * (42 ±0)` - // Estimated: `59431 + c * (2947 ±0)` - // Minimum execution time: 86_517_000 picoseconds. - Weight::from_parts(78_047_954, 59431) - // Standard Error: 2_660 - .saturating_add(Weight::from_parts(1_060_607, 0).saturating_mul(c.into())) + // Measured: `3061 + c * (42 ±0)` + // Estimated: `59827 + c * (2947 ±0)` + // Minimum execution time: 89_781_000 picoseconds. + Weight::from_parts(109_193_287, 59827) + // Standard Error: 2_877 + .saturating_add(Weight::from_parts(1_067_792, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(13_u64)) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(c.into()))) .saturating_add(T::DbWeight::get().writes(9_u64)) @@ -2198,6 +2200,136 @@ impl WeightInfo for SubstrateWeight { // For backwards compatibility and tests impl WeightInfo for () { + /// The range of component `r` is `[0, 1]`. + fn gr_reply(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 94_792_000 picoseconds. + Weight::from_parts(103_063_604, 0) + // Standard Error: 103_375 + .saturating_add(Weight::from_parts(18_929_072, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_reply_wgas(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 96_154_000 picoseconds. + Weight::from_parts(107_249_232, 0) + // Standard Error: 99_969 + .saturating_add(Weight::from_parts(19_062_846, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_reply_commit(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 98_701_000 picoseconds. + Weight::from_parts(109_478_842, 0) + // Standard Error: 104_175 + .saturating_add(Weight::from_parts(10_887_124, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_reply_commit_wgas(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 102_910_000 picoseconds. + Weight::from_parts(109_181_566, 0) + // Standard Error: 81_801 + .saturating_add(Weight::from_parts(12_077_508, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_reply_input(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 719_481_000 picoseconds. + Weight::from_parts(765_485_196, 0) + // Standard Error: 676_170 + .saturating_add(Weight::from_parts(17_778_524, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_reply_input_wgas(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 720_914_000 picoseconds. + Weight::from_parts(776_554_516, 0) + // Standard Error: 1_018_495 + .saturating_add(Weight::from_parts(38_306_948, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_reservation_reply(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 105_823_000 picoseconds. + Weight::from_parts(112_820_586, 0) + // Standard Error: 82_530 + .saturating_add(Weight::from_parts(14_370_506, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_reservation_reply_commit(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 102_415_000 picoseconds. + Weight::from_parts(110_005_402, 0) + // Standard Error: 87_514 + .saturating_add(Weight::from_parts(6_578_880, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_exit(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 96_593_000 picoseconds. + Weight::from_parts(104_873_732, 0) + // Standard Error: 2_095_391 + .saturating_add(Weight::from_parts(193_359_282, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_leave(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 93_619_000 picoseconds. + Weight::from_parts(99_623_244, 0) + // Standard Error: 1_945_328 + .saturating_add(Weight::from_parts(179_784_494, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_wait(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 92_936_000 picoseconds. + Weight::from_parts(100_139_452, 0) + // Standard Error: 1_753_555 + .saturating_add(Weight::from_parts(132_465_876, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_wait_for(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 93_955_000 picoseconds. + Weight::from_parts(100_650_632, 0) + // Standard Error: 2_018_388 + .saturating_add(Weight::from_parts(178_916_382, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_wait_up_to(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 95_467_000 picoseconds. + Weight::from_parts(102_532_790, 0) + // Standard Error: 2_065_180 + .saturating_add(Weight::from_parts(187_152_790, 0).saturating_mul(r.into())) + } fn allocation_cost() -> Weight { // To be changed with the proper value. RocksDbWeight::get().writes(1) @@ -2217,21 +2349,21 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_023_000 picoseconds. - Weight::from_parts(1_051_000, 0) - // Standard Error: 912 - .saturating_add(Weight::from_parts(213_761, 0).saturating_mul(c.into())) + // Minimum execution time: 1_040_000 picoseconds. + Weight::from_parts(1_087_000, 0) + // Standard Error: 940 + .saturating_add(Weight::from_parts(251_751, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().writes(1_u64)) } /// The range of component `c` is `[0, 512]`. fn db_read_per_kb(c: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `146 + c * (1024 ±0)` - // Estimated: `3610 + c * (1024 ±0)` - // Minimum execution time: 3_252_000 picoseconds. - Weight::from_parts(3_416_000, 3610) - // Standard Error: 1_261 - .saturating_add(Weight::from_parts(689_572, 0).saturating_mul(c.into())) + // Measured: `79 + c * (1024 ±0)` + // Estimated: `3543 + c * (1024 ±0)` + // Minimum execution time: 3_333_000 picoseconds. + Weight::from_parts(3_463_000, 3543) + // Standard Error: 966 + .saturating_add(Weight::from_parts(678_430, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(Weight::from_parts(0, 1024).saturating_mul(c.into())) } @@ -2240,35 +2372,35 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 59_805_000 picoseconds. - Weight::from_parts(86_729_126, 0) - // Standard Error: 7_023 - .saturating_add(Weight::from_parts(2_475_519, 0).saturating_mul(c.into())) + // Minimum execution time: 61_586_000 picoseconds. + Weight::from_parts(95_956_778, 0) + // Standard Error: 5_472 + .saturating_add(Weight::from_parts(2_353_352, 0).saturating_mul(c.into())) } fn claim_value() -> Weight { // Proof Size summary in bytes: - // Measured: `1372` - // Estimated: `51905` - // Minimum execution time: 107_694_000 picoseconds. - Weight::from_parts(110_328_000, 51905) + // Measured: `1304` + // Estimated: `51293` + // Minimum execution time: 105_420_000 picoseconds. + Weight::from_parts(109_120_000, 51293) .saturating_add(RocksDbWeight::get().reads(15_u64)) .saturating_add(RocksDbWeight::get().writes(12_u64)) } fn pay_program_rent() -> Weight { // Proof Size summary in bytes: - // Measured: `992` - // Estimated: `21579` - // Minimum execution time: 55_980_000 picoseconds. - Weight::from_parts(56_766_000, 21579) + // Measured: `923` + // Estimated: `21372` + // Minimum execution time: 54_290_000 picoseconds. + Weight::from_parts(55_929_000, 21372) .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().writes(6_u64)) } fn resume_session_init() -> Weight { // Proof Size summary in bytes: - // Measured: `638` - // Estimated: `17486` - // Minimum execution time: 29_973_000 picoseconds. - Weight::from_parts(31_008_000, 17486) + // Measured: `570` + // Estimated: `17214` + // Minimum execution time: 29_539_000 picoseconds. + Weight::from_parts(30_515_000, 17214) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().writes(4_u64)) } @@ -2277,22 +2409,22 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `355` // Estimated: `7640` - // Minimum execution time: 8_054_000 picoseconds. - Weight::from_parts(8_342_000, 7640) - // Standard Error: 17_771 - .saturating_add(Weight::from_parts(13_335_661, 0).saturating_mul(c.into())) + // Minimum execution time: 8_426_000 picoseconds. + Weight::from_parts(5_984_423, 7640) + // Standard Error: 33_789 + .saturating_add(Weight::from_parts(13_895_151, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) } /// The range of component `c` is `[0, 2044]`. fn resume_session_commit(c: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `1593 + c * (16389 ±0)` - // Estimated: `43266 + c * (131112 ±0)` - // Minimum execution time: 72_178_000 picoseconds. - Weight::from_parts(73_341_000, 43266) - // Standard Error: 167_723 - .saturating_add(Weight::from_parts(54_442_045, 0).saturating_mul(c.into())) + // Measured: `1457 + c * (16389 ±0)` + // Estimated: `42178 + c * (131112 ±0)` + // Minimum execution time: 71_198_000 picoseconds. + Weight::from_parts(72_033_000, 42178) + // Standard Error: 159_543 + .saturating_add(Weight::from_parts(54_764_270, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(11_u64)) .saturating_add(RocksDbWeight::get().writes(9_u64)) .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(c.into()))) @@ -2301,24 +2433,24 @@ impl WeightInfo for () { /// The range of component `c` is `[0, 250]`. fn upload_code(c: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `113` - // Estimated: `5402` - // Minimum execution time: 78_662_000 picoseconds. - Weight::from_parts(42_066_175, 5402) - // Standard Error: 52_075 - .saturating_add(Weight::from_parts(60_249_549, 0).saturating_mul(c.into())) + // Measured: `46` + // Estimated: `5134` + // Minimum execution time: 77_259_000 picoseconds. + Weight::from_parts(52_968_469, 5134) + // Standard Error: 43_186 + .saturating_add(Weight::from_parts(59_988_588, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(4_u64)) } /// The range of component `s` is `[0, 4194304]`. fn create_program(s: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `1111` - // Estimated: `50600` - // Minimum execution time: 94_321_000 picoseconds. - Weight::from_parts(129_113_540, 50600) - // Standard Error: 1 - .saturating_add(Weight::from_parts(2_625, 0).saturating_mul(s.into())) + // Measured: `1043` + // Estimated: `49852` + // Minimum execution time: 96_734_000 picoseconds. + Weight::from_parts(136_364_170, 49852) + // Standard Error: 0 + .saturating_add(Weight::from_parts(2_592, 0).saturating_mul(s.into())) .saturating_add(RocksDbWeight::get().reads(15_u64)) .saturating_add(RocksDbWeight::get().writes(12_u64)) } @@ -2326,72 +2458,72 @@ impl WeightInfo for () { /// The range of component `s` is `[0, 4194304]`. fn upload_program(c: u32, s: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `521` - // Estimated: `45152` - // Minimum execution time: 11_148_491_000 picoseconds. - Weight::from_parts(21_065_971, 45152) - // Standard Error: 173_883 - .saturating_add(Weight::from_parts(60_839_567, 0).saturating_mul(c.into())) - // Standard Error: 10 - .saturating_add(Weight::from_parts(2_652, 0).saturating_mul(s.into())) + // Measured: `453` + // Estimated: `44268` + // Minimum execution time: 11_047_048_000 picoseconds. + Weight::from_parts(211_012_859, 44268) + // Standard Error: 157_221 + .saturating_add(Weight::from_parts(59_860_835, 0).saturating_mul(c.into())) + // Standard Error: 9 + .saturating_add(Weight::from_parts(2_554, 0).saturating_mul(s.into())) .saturating_add(RocksDbWeight::get().reads(15_u64)) .saturating_add(RocksDbWeight::get().writes(16_u64)) } /// The range of component `p` is `[0, 2097152]`. fn send_message(p: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `531` - // Estimated: `31266` - // Minimum execution time: 73_302_000 picoseconds. - Weight::from_parts(47_279_667, 31266) + // Measured: `530` + // Estimated: `31259` + // Minimum execution time: 73_682_000 picoseconds. + Weight::from_parts(48_414_295, 31259) // Standard Error: 1 - .saturating_add(Weight::from_parts(1_055, 0).saturating_mul(p.into())) + .saturating_add(Weight::from_parts(1_040, 0).saturating_mul(p.into())) .saturating_add(RocksDbWeight::get().reads(11_u64)) .saturating_add(RocksDbWeight::get().writes(10_u64)) } /// The range of component `p` is `[0, 2097152]`. fn send_reply(p: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `1371` - // Estimated: `54435` - // Minimum execution time: 124_173_000 picoseconds. - Weight::from_parts(96_458_887, 54435) - // Standard Error: 2 - .saturating_add(Weight::from_parts(1_078, 0).saturating_mul(p.into())) + // Measured: `1303` + // Estimated: `53823` + // Minimum execution time: 122_837_000 picoseconds. + Weight::from_parts(97_209_014, 53823) + // Standard Error: 1 + .saturating_add(Weight::from_parts(1_068, 0).saturating_mul(p.into())) .saturating_add(RocksDbWeight::get().reads(16_u64)) .saturating_add(RocksDbWeight::get().writes(13_u64)) } /// The range of component `q` is `[1, 512]`. fn initial_allocation(_q: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `1893` - // Estimated: `114612` - // Minimum execution time: 365_983_000 picoseconds. - Weight::from_parts(387_416_952, 114612) - .saturating_add(RocksDbWeight::get().reads(33_u64)) - .saturating_add(RocksDbWeight::get().writes(26_u64)) + // Measured: `979` + // Estimated: `89393` + // Minimum execution time: 354_207_000 picoseconds. + Weight::from_parts(374_297_966, 89393) + .saturating_add(RocksDbWeight::get().reads(31_u64)) + .saturating_add(RocksDbWeight::get().writes(24_u64)) } /// The range of component `q` is `[0, 512]`. fn alloc_in_handle(q: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `1893` - // Estimated: `114612` - // Minimum execution time: 380_430_000 picoseconds. - Weight::from_parts(403_376_118, 114612) - // Standard Error: 2_451 - .saturating_add(Weight::from_parts(1_137, 0).saturating_mul(q.into())) - .saturating_add(RocksDbWeight::get().reads(33_u64)) - .saturating_add(RocksDbWeight::get().writes(26_u64)) + // Measured: `979` + // Estimated: `89133` + // Minimum execution time: 368_424_000 picoseconds. + Weight::from_parts(387_073_481, 89133) + // Standard Error: 1_472 + .saturating_add(Weight::from_parts(4_343, 0).saturating_mul(q.into())) + .saturating_add(RocksDbWeight::get().reads(31_u64)) + .saturating_add(RocksDbWeight::get().writes(24_u64)) } /// The range of component `c` is `[0, 512]`. fn reinstrument_per_kb(c: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `211 + c * (1075 ±0)` // Estimated: `3899 + c * (2150 ±0)` - // Minimum execution time: 58_080_000 picoseconds. - Weight::from_parts(58_601_000, 3899) - // Standard Error: 36_083 - .saturating_add(Weight::from_parts(58_395_643, 0).saturating_mul(c.into())) + // Minimum execution time: 58_209_000 picoseconds. + Weight::from_parts(58_498_000, 3899) + // Standard Error: 35_860 + .saturating_add(Weight::from_parts(58_109_594, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) .saturating_add(Weight::from_parts(0, 2150).saturating_mul(c.into())) @@ -2401,638 +2533,510 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 91_412_000 picoseconds. - Weight::from_parts(94_168_000, 0) - // Standard Error: 3_806_298 - .saturating_add(Weight::from_parts(673_774_453, 0).saturating_mul(r.into())) + // Minimum execution time: 92_645_000 picoseconds. + Weight::from_parts(95_763_000, 0) + // Standard Error: 3_691_564 + .saturating_add(Weight::from_parts(713_537_659, 0).saturating_mul(r.into())) } /// The range of component `p` is `[1, 512]`. fn alloc_per_page(p: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 452_549_000 picoseconds. - Weight::from_parts(398_963_700, 0) - // Standard Error: 7_042 - .saturating_add(Weight::from_parts(29_406_609, 0).saturating_mul(p.into())) + // Minimum execution time: 495_006_000 picoseconds. + Weight::from_parts(421_459_793, 0) + // Standard Error: 9_156 + .saturating_add(Weight::from_parts(29_070_022, 0).saturating_mul(p.into())) } /// The range of component `r` is `[0, 20]`. fn free(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 207_052_000 picoseconds. - Weight::from_parts(209_606_478, 0) - // Standard Error: 255_281 - .saturating_add(Weight::from_parts(62_959_531, 0).saturating_mul(r.into())) + // Minimum execution time: 219_414_000 picoseconds. + Weight::from_parts(206_118_379, 0) + // Standard Error: 320_555 + .saturating_add(Weight::from_parts(64_665_141, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 256]`. fn gr_reserve_gas(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 97_729_000 picoseconds. - Weight::from_parts(105_964_750, 0) - // Standard Error: 4_847 - .saturating_add(Weight::from_parts(2_433_966, 0).saturating_mul(r.into())) + // Minimum execution time: 96_871_000 picoseconds. + Weight::from_parts(104_318_392, 0) + // Standard Error: 4_224 + .saturating_add(Weight::from_parts(2_443_618, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 256]`. fn gr_unreserve_gas(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 175_010_000 picoseconds. - Weight::from_parts(229_153_209, 0) - // Standard Error: 17_116 - .saturating_add(Weight::from_parts(1_991_260, 0).saturating_mul(r.into())) + // Minimum execution time: 152_658_000 picoseconds. + Weight::from_parts(218_177_774, 0) + // Standard Error: 23_640 + .saturating_add(Weight::from_parts(2_186_094, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_system_reserve_gas(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 94_696_000 picoseconds. - Weight::from_parts(119_674_535, 0) - // Standard Error: 387_178 - .saturating_add(Weight::from_parts(98_102_856, 0).saturating_mul(r.into())) + // Minimum execution time: 97_532_000 picoseconds. + Weight::from_parts(112_244_990, 0) + // Standard Error: 370_435 + .saturating_add(Weight::from_parts(102_977_688, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_message_id(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 95_794_000 picoseconds. - Weight::from_parts(89_931_979, 0) - // Standard Error: 371_349 - .saturating_add(Weight::from_parts(86_524_059, 0).saturating_mul(r.into())) + // Minimum execution time: 95_116_000 picoseconds. + Weight::from_parts(85_754_801, 0) + // Standard Error: 322_936 + .saturating_add(Weight::from_parts(85_646_040, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_program_id(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 97_924_000 picoseconds. - Weight::from_parts(84_041_201, 0) - // Standard Error: 327_841 - .saturating_add(Weight::from_parts(95_483_315, 0).saturating_mul(r.into())) + // Minimum execution time: 97_226_000 picoseconds. + Weight::from_parts(96_400_189, 0) + // Standard Error: 308_975 + .saturating_add(Weight::from_parts(84_400_658, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_source(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 97_122_000 picoseconds. - Weight::from_parts(86_789_268, 0) - // Standard Error: 353_259 - .saturating_add(Weight::from_parts(85_698_317, 0).saturating_mul(r.into())) + // Minimum execution time: 96_667_000 picoseconds. + Weight::from_parts(95_221_535, 0) + // Standard Error: 320_528 + .saturating_add(Weight::from_parts(85_320_330, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_value(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 94_821_000 picoseconds. - Weight::from_parts(92_694_130, 0) - // Standard Error: 340_146 - .saturating_add(Weight::from_parts(84_623_945, 0).saturating_mul(r.into())) + // Minimum execution time: 96_400_000 picoseconds. + Weight::from_parts(83_830_464, 0) + // Standard Error: 333_677 + .saturating_add(Weight::from_parts(86_153_462, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_value_available(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 93_840_000 picoseconds. - Weight::from_parts(87_888_572, 0) - // Standard Error: 369_465 - .saturating_add(Weight::from_parts(85_638_902, 0).saturating_mul(r.into())) + // Minimum execution time: 98_322_000 picoseconds. + Weight::from_parts(88_780_011, 0) + // Standard Error: 365_736 + .saturating_add(Weight::from_parts(86_373_607, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_gas_available(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 98_597_000 picoseconds. - Weight::from_parts(86_642_386, 0) - // Standard Error: 362_257 - .saturating_add(Weight::from_parts(85_598_887, 0).saturating_mul(r.into())) + // Minimum execution time: 94_234_000 picoseconds. + Weight::from_parts(93_394_916, 0) + // Standard Error: 310_495 + .saturating_add(Weight::from_parts(85_678_300, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_size(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 94_546_000 picoseconds. - Weight::from_parts(91_466_289, 0) - // Standard Error: 344_423 - .saturating_add(Weight::from_parts(84_318_848, 0).saturating_mul(r.into())) + // Minimum execution time: 95_316_000 picoseconds. + Weight::from_parts(88_012_950, 0) + // Standard Error: 309_598 + .saturating_add(Weight::from_parts(85_813_369, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_read(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 578_036_000 picoseconds. - Weight::from_parts(696_140_951, 0) - // Standard Error: 559_498 - .saturating_add(Weight::from_parts(149_397_501, 0).saturating_mul(r.into())) + // Minimum execution time: 715_150_000 picoseconds. + Weight::from_parts(769_593_524, 0) + // Standard Error: 493_525 + .saturating_add(Weight::from_parts(140_935_499, 0).saturating_mul(r.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_read_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 723_788_000 picoseconds. - Weight::from_parts(740_225_000, 0) - // Standard Error: 52_895 - .saturating_add(Weight::from_parts(13_188_120, 0).saturating_mul(n.into())) + // Minimum execution time: 844_162_000 picoseconds. + Weight::from_parts(851_053_000, 0) + // Standard Error: 50_294 + .saturating_add(Weight::from_parts(13_068_816, 0).saturating_mul(n.into())) } /// The range of component `r` is `[0, 20]`. fn gr_block_height(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 99_012_000 picoseconds. - Weight::from_parts(88_269_135, 0) - // Standard Error: 296_136 - .saturating_add(Weight::from_parts(92_296_104, 0).saturating_mul(r.into())) + // Minimum execution time: 94_243_000 picoseconds. + Weight::from_parts(87_583_955, 0) + // Standard Error: 343_578 + .saturating_add(Weight::from_parts(84_267_053, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_block_timestamp(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 93_803_000 picoseconds. - Weight::from_parts(87_097_769, 0) - // Standard Error: 367_325 - .saturating_add(Weight::from_parts(84_987_043, 0).saturating_mul(r.into())) + // Minimum execution time: 95_559_000 picoseconds. + Weight::from_parts(92_460_596, 0) + // Standard Error: 340_344 + .saturating_add(Weight::from_parts(85_006_110, 0).saturating_mul(r.into())) } /// The range of component `n` is `[0, 20]`. fn gr_random(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 96_663_000 picoseconds. - Weight::from_parts(105_357_427, 0) - // Standard Error: 366_135 - .saturating_add(Weight::from_parts(172_109_201, 0).saturating_mul(n.into())) + // Minimum execution time: 95_023_000 picoseconds. + Weight::from_parts(113_045_564, 0) + // Standard Error: 350_542 + .saturating_add(Weight::from_parts(169_289_972, 0).saturating_mul(n.into())) } /// The range of component `r` is `[0, 20]`. fn gr_reply_deposit(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 99_210_000 picoseconds. - Weight::from_parts(102_217_000, 0) - // Standard Error: 4_527_119 - .saturating_add(Weight::from_parts(845_784_967, 0).saturating_mul(r.into())) + // Minimum execution time: 95_407_000 picoseconds. + Weight::from_parts(99_094_000, 0) + // Standard Error: 3_585_438 + .saturating_add(Weight::from_parts(776_362_449, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_send(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 96_579_000 picoseconds. - Weight::from_parts(162_452_429, 0) - // Standard Error: 416_836 - .saturating_add(Weight::from_parts(257_900_517, 0).saturating_mul(r.into())) + // Minimum execution time: 96_709_000 picoseconds. + Weight::from_parts(153_262_764, 0) + // Standard Error: 391_637 + .saturating_add(Weight::from_parts(256_389_022, 0).saturating_mul(r.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_send_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 353_526_000 picoseconds. - Weight::from_parts(358_025_000, 0) - // Standard Error: 61_984 - .saturating_add(Weight::from_parts(21_521_461, 0).saturating_mul(n.into())) + // Minimum execution time: 341_633_000 picoseconds. + Weight::from_parts(345_693_000, 0) + // Standard Error: 61_029 + .saturating_add(Weight::from_parts(21_298_548, 0).saturating_mul(n.into())) } /// The range of component `r` is `[0, 20]`. fn gr_send_wgas(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 94_822_000 picoseconds. - Weight::from_parts(168_431_611, 0) - // Standard Error: 378_696 - .saturating_add(Weight::from_parts(263_135_958, 0).saturating_mul(r.into())) + // Minimum execution time: 97_817_000 picoseconds. + Weight::from_parts(172_033_153, 0) + // Standard Error: 412_230 + .saturating_add(Weight::from_parts(260_826_119, 0).saturating_mul(r.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_send_wgas_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 351_828_000 picoseconds. - Weight::from_parts(355_382_000, 0) - // Standard Error: 60_589 - .saturating_add(Weight::from_parts(21_325_400, 0).saturating_mul(n.into())) + // Minimum execution time: 353_433_000 picoseconds. + Weight::from_parts(359_185_000, 0) + // Standard Error: 60_153 + .saturating_add(Weight::from_parts(21_224_949, 0).saturating_mul(n.into())) } /// The range of component `r` is `[0, 20]`. fn gr_send_input(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 569_384_000 picoseconds. - Weight::from_parts(638_474_730, 0) - // Standard Error: 425_903 - .saturating_add(Weight::from_parts(275_691_711, 0).saturating_mul(r.into())) + // Minimum execution time: 716_180_000 picoseconds. + Weight::from_parts(782_890_839, 0) + // Standard Error: 547_225 + .saturating_add(Weight::from_parts(273_570_636, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_send_input_wgas(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 573_053_000 picoseconds. - Weight::from_parts(640_078_802, 0) - // Standard Error: 475_389 - .saturating_add(Weight::from_parts(284_337_155, 0).saturating_mul(r.into())) + // Minimum execution time: 719_827_000 picoseconds. + Weight::from_parts(805_763_844, 0) + // Standard Error: 503_245 + .saturating_add(Weight::from_parts(278_200_889, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_send_init(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 98_223_000 picoseconds. - Weight::from_parts(85_732_985, 0) - // Standard Error: 336_308 - .saturating_add(Weight::from_parts(92_936_006, 0).saturating_mul(r.into())) + // Minimum execution time: 96_518_000 picoseconds. + Weight::from_parts(82_218_173, 0) + // Standard Error: 358_867 + .saturating_add(Weight::from_parts(92_408_337, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_send_push(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_822_621_000 picoseconds. - Weight::from_parts(1_951_955_018, 0) - // Standard Error: 339_415 - .saturating_add(Weight::from_parts(157_557_756, 0).saturating_mul(r.into())) + // Minimum execution time: 1_829_368_000 picoseconds. + Weight::from_parts(1_976_758_302, 0) + // Standard Error: 349_703 + .saturating_add(Weight::from_parts(163_038_781, 0).saturating_mul(r.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_send_push_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 314_296_000 picoseconds. - Weight::from_parts(317_522_000, 0) - // Standard Error: 61_360 - .saturating_add(Weight::from_parts(29_499_741, 0).saturating_mul(n.into())) + // Minimum execution time: 315_829_000 picoseconds. + Weight::from_parts(318_464_000, 0) + // Standard Error: 54_637 + .saturating_add(Weight::from_parts(31_280_567, 0).saturating_mul(n.into())) } /// The range of component `r` is `[0, 20]`. fn gr_send_commit(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_835_106_000 picoseconds. - Weight::from_parts(1_948_516_646, 0) - // Standard Error: 382_008 - .saturating_add(Weight::from_parts(214_812_508, 0).saturating_mul(r.into())) + // Minimum execution time: 1_818_937_000 picoseconds. + Weight::from_parts(1_941_969_566, 0) + // Standard Error: 412_244 + .saturating_add(Weight::from_parts(220_650_756, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_send_commit_wgas(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_827_496_000 picoseconds. - Weight::from_parts(1_949_190_773, 0) - // Standard Error: 340_175 - .saturating_add(Weight::from_parts(218_001_536, 0).saturating_mul(r.into())) + // Minimum execution time: 1_815_762_000 picoseconds. + Weight::from_parts(1_958_182_203, 0) + // Standard Error: 374_381 + .saturating_add(Weight::from_parts(229_106_637, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_reservation_send(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 264_306_000 picoseconds. - Weight::from_parts(363_536_651, 0) - // Standard Error: 467_914 - .saturating_add(Weight::from_parts(265_564_072, 0).saturating_mul(r.into())) + // Minimum execution time: 259_040_000 picoseconds. + Weight::from_parts(345_586_401, 0) + // Standard Error: 402_258 + .saturating_add(Weight::from_parts(274_866_021, 0).saturating_mul(r.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_reservation_send_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 523_150_000 picoseconds. - Weight::from_parts(535_842_000, 0) - // Standard Error: 65_412 - .saturating_add(Weight::from_parts(21_698_063, 0).saturating_mul(n.into())) + // Minimum execution time: 523_014_000 picoseconds. + Weight::from_parts(525_681_000, 0) + // Standard Error: 56_470 + .saturating_add(Weight::from_parts(21_443_571, 0).saturating_mul(n.into())) } /// The range of component `r` is `[0, 20]`. fn gr_reservation_send_commit(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_974_743_000 picoseconds. - Weight::from_parts(2_096_494_995, 0) - // Standard Error: 474_778 - .saturating_add(Weight::from_parts(232_524_299, 0).saturating_mul(r.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_reply(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 94_139_000 picoseconds. - Weight::from_parts(101_775_569, 0) - // Standard Error: 452_439 - .saturating_add(Weight::from_parts(16_839_430, 0).saturating_mul(r.into())) + // Minimum execution time: 1_967_181_000 picoseconds. + Weight::from_parts(2_076_078_781, 0) + // Standard Error: 455_370 + .saturating_add(Weight::from_parts(246_494_683, 0).saturating_mul(r.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_reply_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 112_050_000 picoseconds. - Weight::from_parts(102_205_366, 0) - // Standard Error: 1_008 - .saturating_add(Weight::from_parts(431_304, 0).saturating_mul(n.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_reply_wgas(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 93_528_000 picoseconds. - Weight::from_parts(99_748_422, 0) - // Standard Error: 396_992 - .saturating_add(Weight::from_parts(20_536_877, 0).saturating_mul(r.into())) + // Minimum execution time: 114_790_000 picoseconds. + Weight::from_parts(106_908_278, 0) + // Standard Error: 1_274 + .saturating_add(Weight::from_parts(430_785, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_reply_wgas_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 117_832_000 picoseconds. - Weight::from_parts(104_552_847, 0) - // Standard Error: 1_402 - .saturating_add(Weight::from_parts(432_018, 0).saturating_mul(n.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_reply_commit(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 93_325_000 picoseconds. - Weight::from_parts(101_074_097, 0) - // Standard Error: 454_790 - .saturating_add(Weight::from_parts(20_838_102, 0).saturating_mul(r.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_reply_commit_wgas(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 93_800_000 picoseconds. - Weight::from_parts(102_249_326, 0) - // Standard Error: 463_488 - .saturating_add(Weight::from_parts(15_991_473, 0).saturating_mul(r.into())) + // Minimum execution time: 115_541_000 picoseconds. + Weight::from_parts(101_956_035, 0) + // Standard Error: 3_603 + .saturating_add(Weight::from_parts(442_387, 0).saturating_mul(n.into())) } /// The range of component `r` is `[0, 20]`. fn gr_reply_push(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 93_153_000 picoseconds. - Weight::from_parts(121_452_989, 0) - // Standard Error: 390_540 - .saturating_add(Weight::from_parts(145_641_178, 0).saturating_mul(r.into())) + // Minimum execution time: 94_082_000 picoseconds. + Weight::from_parts(138_243_307, 0) + // Standard Error: 409_163 + .saturating_add(Weight::from_parts(154_758_505, 0).saturating_mul(r.into())) } /// The range of component `n` is `[0, 8192]`. fn gr_reply_push_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 115_529_000 picoseconds. - Weight::from_parts(120_413_000, 0) - // Standard Error: 3_105 - .saturating_add(Weight::from_parts(640_863, 0).saturating_mul(n.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_reply_input(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 566_859_000 picoseconds. - Weight::from_parts(631_111_316, 0) - // Standard Error: 7_012_228 - .saturating_add(Weight::from_parts(21_896_983, 0).saturating_mul(r.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_reply_input_wgas(_r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 565_382_000 picoseconds. - Weight::from_parts(613_048_008, 0) - } - /// The range of component `r` is `[0, 1]`. - fn gr_reservation_reply(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 104_401_000 picoseconds. - Weight::from_parts(112_651_320, 0) - // Standard Error: 438_590 - .saturating_add(Weight::from_parts(11_095_379, 0).saturating_mul(r.into())) + // Minimum execution time: 111_536_000 picoseconds. + Weight::from_parts(114_497_000, 0) + // Standard Error: 2_599 + .saturating_add(Weight::from_parts(656_994, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_reservation_reply_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 115_615_000 picoseconds. - Weight::from_parts(112_987_750, 0) - // Standard Error: 960 - .saturating_add(Weight::from_parts(423_774, 0).saturating_mul(n.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_reservation_reply_commit(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 105_056_000 picoseconds. - Weight::from_parts(113_735_922, 0) - // Standard Error: 466_586 - .saturating_add(Weight::from_parts(5_305_577, 0).saturating_mul(r.into())) + // Minimum execution time: 114_322_000 picoseconds. + Weight::from_parts(113_131_028, 0) + // Standard Error: 3_727 + .saturating_add(Weight::from_parts(436_168, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_reservation_reply_commit_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 113_897_000 picoseconds. - Weight::from_parts(112_616_408, 0) - // Standard Error: 1_722 - .saturating_add(Weight::from_parts(428_420, 0).saturating_mul(n.into())) + // Minimum execution time: 117_751_000 picoseconds. + Weight::from_parts(161_418_174, 0) + // Standard Error: 6_635 + .saturating_add(Weight::from_parts(405_229, 0).saturating_mul(n.into())) } /// The range of component `r` is `[0, 20]`. fn gr_reply_to(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 93_845_000 picoseconds. - Weight::from_parts(97_247_314, 0) - // Standard Error: 366_814 - .saturating_add(Weight::from_parts(85_900_587, 0).saturating_mul(r.into())) + // Minimum execution time: 93_524_000 picoseconds. + Weight::from_parts(89_332_032, 0) + // Standard Error: 294_566 + .saturating_add(Weight::from_parts(86_798_759, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_signal_code(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 98_960_000 picoseconds. - Weight::from_parts(96_741_705, 0) - // Standard Error: 331_442 - .saturating_add(Weight::from_parts(82_371_743, 0).saturating_mul(r.into())) + // Minimum execution time: 95_216_000 picoseconds. + Weight::from_parts(83_424_786, 0) + // Standard Error: 316_301 + .saturating_add(Weight::from_parts(84_774_296, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_signal_from(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 95_150_000 picoseconds. - Weight::from_parts(94_807_000, 0) - // Standard Error: 308_494 - .saturating_add(Weight::from_parts(85_723_479, 0).saturating_mul(r.into())) + // Minimum execution time: 96_461_000 picoseconds. + Weight::from_parts(97_636_300, 0) + // Standard Error: 278_297 + .saturating_add(Weight::from_parts(86_743_159, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_reply_push_input(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 565_388_000 picoseconds. - Weight::from_parts(606_358_854, 0) - // Standard Error: 430_766 - .saturating_add(Weight::from_parts(108_769_267, 0).saturating_mul(r.into())) + // Minimum execution time: 724_902_000 picoseconds. + Weight::from_parts(784_128_285, 0) + // Standard Error: 444_406 + .saturating_add(Weight::from_parts(105_223_470, 0).saturating_mul(r.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_reply_push_input_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 591_660_000 picoseconds. - Weight::from_parts(597_035_528, 0) - // Standard Error: 2_641 - .saturating_add(Weight::from_parts(153_781, 0).saturating_mul(n.into())) + // Minimum execution time: 737_666_000 picoseconds. + Weight::from_parts(758_797_216, 0) + // Standard Error: 1_260 + .saturating_add(Weight::from_parts(154_837, 0).saturating_mul(n.into())) } /// The range of component `r` is `[0, 20]`. fn gr_send_push_input(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_317_147_000 picoseconds. - Weight::from_parts(2_514_940_964, 0) - // Standard Error: 546_319 - .saturating_add(Weight::from_parts(128_825_542, 0).saturating_mul(r.into())) + // Minimum execution time: 2_498_871_000 picoseconds. + Weight::from_parts(2_688_516_696, 0) + // Standard Error: 531_545 + .saturating_add(Weight::from_parts(131_060_314, 0).saturating_mul(r.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_send_push_input_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_560_344_000 picoseconds. - Weight::from_parts(2_512_409_449, 0) - // Standard Error: 15_466 - .saturating_add(Weight::from_parts(12_395_144, 0).saturating_mul(n.into())) + // Minimum execution time: 2_657_855_000 picoseconds. + Weight::from_parts(2_746_003_287, 0) + // Standard Error: 12_743 + .saturating_add(Weight::from_parts(13_716_214, 0).saturating_mul(n.into())) } /// The range of component `r` is `[0, 20]`. fn gr_debug(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 97_996_000 picoseconds. - Weight::from_parts(130_630_238, 0) - // Standard Error: 414_418 - .saturating_add(Weight::from_parts(114_735_577, 0).saturating_mul(r.into())) + // Minimum execution time: 96_990_000 picoseconds. + Weight::from_parts(110_812_744, 0) + // Standard Error: 347_035 + .saturating_add(Weight::from_parts(120_462_128, 0).saturating_mul(r.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_debug_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 157_513_000 picoseconds. - Weight::from_parts(160_584_000, 0) - // Standard Error: 57_227 - .saturating_add(Weight::from_parts(25_738_939, 0).saturating_mul(n.into())) + // Minimum execution time: 170_244_000 picoseconds. + Weight::from_parts(175_502_000, 0) + // Standard Error: 56_203 + .saturating_add(Weight::from_parts(25_870_902, 0).saturating_mul(n.into())) } /// The range of component `r` is `[0, 20]`. fn gr_reply_code(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 92_652_000 picoseconds. - Weight::from_parts(88_138_429, 0) - // Standard Error: 330_537 - .saturating_add(Weight::from_parts(83_235_234, 0).saturating_mul(r.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_exit(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 93_824_000 picoseconds. - Weight::from_parts(102_740_497, 0) - // Standard Error: 428_593 - .saturating_add(Weight::from_parts(23_682_102, 0).saturating_mul(r.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_leave(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 92_530_000 picoseconds. - Weight::from_parts(101_410_861, 0) - // Standard Error: 432_236 - .saturating_add(Weight::from_parts(12_196_938, 0).saturating_mul(r.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_wait(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 93_402_000 picoseconds. - Weight::from_parts(102_285_877, 0) - // Standard Error: 466_463 - .saturating_add(Weight::from_parts(13_156_522, 0).saturating_mul(r.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_wait_for(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 95_706_000 picoseconds. - Weight::from_parts(102_513_059, 0) - // Standard Error: 464_787 - .saturating_add(Weight::from_parts(13_986_540, 0).saturating_mul(r.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_wait_up_to(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 93_057_000 picoseconds. - Weight::from_parts(99_083_869, 0) - // Standard Error: 378_747 - .saturating_add(Weight::from_parts(12_230_330, 0).saturating_mul(r.into())) + // Minimum execution time: 97_676_000 picoseconds. + Weight::from_parts(91_226_383, 0) + // Standard Error: 320_296 + .saturating_add(Weight::from_parts(82_761_490, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_wake(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 177_947_000 picoseconds. - Weight::from_parts(226_692_243, 0) - // Standard Error: 265_725 - .saturating_add(Weight::from_parts(156_938_838, 0).saturating_mul(r.into())) + // Minimum execution time: 149_319_000 picoseconds. + Weight::from_parts(230_971_562, 0) + // Standard Error: 338_138 + .saturating_add(Weight::from_parts(157_262_608, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_create_program(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 107_346_000 picoseconds. - Weight::from_parts(160_631_540, 0) - // Standard Error: 352_753 - .saturating_add(Weight::from_parts(338_685_448, 0).saturating_mul(r.into())) + // Minimum execution time: 108_167_000 picoseconds. + Weight::from_parts(178_994_489, 0) + // Standard Error: 404_012 + .saturating_add(Weight::from_parts(348_487_075, 0).saturating_mul(r.into())) } /// The range of component `p` is `[0, 2048]`. /// The range of component `s` is `[1, 2048]`. @@ -3040,22 +3044,22 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 44_754_074_000 picoseconds. - Weight::from_parts(44_833_050_000, 0) - // Standard Error: 269_308 - .saturating_add(Weight::from_parts(7_629_892, 0).saturating_mul(p.into())) - // Standard Error: 269_294 - .saturating_add(Weight::from_parts(179_148_245, 0).saturating_mul(s.into())) + // Minimum execution time: 43_645_119_000 picoseconds. + Weight::from_parts(43_811_648_000, 0) + // Standard Error: 262_276 + .saturating_add(Weight::from_parts(7_776_587, 0).saturating_mul(p.into())) + // Standard Error: 262_263 + .saturating_add(Weight::from_parts(178_958_075, 0).saturating_mul(s.into())) } /// The range of component `r` is `[0, 20]`. fn gr_create_program_wgas(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 108_278_000 picoseconds. - Weight::from_parts(161_208_126, 0) - // Standard Error: 368_644 - .saturating_add(Weight::from_parts(346_324_329, 0).saturating_mul(r.into())) + // Minimum execution time: 104_639_000 picoseconds. + Weight::from_parts(169_517_206, 0) + // Standard Error: 363_225 + .saturating_add(Weight::from_parts(357_078_703, 0).saturating_mul(r.into())) } /// The range of component `p` is `[0, 2048]`. /// The range of component `s` is `[1, 2048]`. @@ -3063,32 +3067,32 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 44_266_209_000 picoseconds. - Weight::from_parts(44_559_345_000, 0) - // Standard Error: 270_420 - .saturating_add(Weight::from_parts(7_460_172, 0).saturating_mul(p.into())) - // Standard Error: 270_407 - .saturating_add(Weight::from_parts(179_211_260, 0).saturating_mul(s.into())) + // Minimum execution time: 46_491_851_000 picoseconds. + Weight::from_parts(46_603_783_000, 0) + // Standard Error: 280_431 + .saturating_add(Weight::from_parts(7_250_257, 0).saturating_mul(p.into())) + // Standard Error: 280_417 + .saturating_add(Weight::from_parts(177_722_888, 0).saturating_mul(s.into())) } /// The range of component `r` is `[0, 20]`. fn gr_pay_program_rent(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 94_889_000 picoseconds. - Weight::from_parts(115_310_524, 0) - // Standard Error: 34_049 - .saturating_add(Weight::from_parts(1_916_607, 0).saturating_mul(r.into())) + // Minimum execution time: 95_721_000 picoseconds. + Weight::from_parts(114_995_832, 0) + // Standard Error: 36_809 + .saturating_add(Weight::from_parts(1_873_016, 0).saturating_mul(r.into())) } /// The range of component `p` is `[0, 512]`. fn lazy_pages_signal_read(p: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `141` // Estimated: `1131 + p * (9900 ±0)` - // Minimum execution time: 97_825_000 picoseconds. - Weight::from_parts(251_440_245, 1131) - // Standard Error: 70_641 - .saturating_add(Weight::from_parts(15_652_952, 0).saturating_mul(p.into())) + // Minimum execution time: 97_655_000 picoseconds. + Weight::from_parts(138_058_498, 1131) + // Standard Error: 18_813 + .saturating_add(Weight::from_parts(16_311_194, 0).saturating_mul(p.into())) .saturating_add(RocksDbWeight::get().reads((4_u64).saturating_mul(p.into()))) .saturating_add(Weight::from_parts(0, 9900).saturating_mul(p.into())) } @@ -3097,10 +3101,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `141` // Estimated: `1131 + p * (9900 ±0)` - // Minimum execution time: 96_761_000 picoseconds. - Weight::from_parts(100_398_000, 1131) - // Standard Error: 45_532 - .saturating_add(Weight::from_parts(39_790_625, 0).saturating_mul(p.into())) + // Minimum execution time: 96_083_000 picoseconds. + Weight::from_parts(98_597_000, 1131) + // Standard Error: 43_515 + .saturating_add(Weight::from_parts(42_632_421, 0).saturating_mul(p.into())) .saturating_add(RocksDbWeight::get().reads((4_u64).saturating_mul(p.into()))) .saturating_add(Weight::from_parts(0, 9900).saturating_mul(p.into())) } @@ -3109,10 +3113,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `141` // Estimated: `5069931` - // Minimum execution time: 7_471_807_000 picoseconds. - Weight::from_parts(7_440_591_962, 5069931) - // Standard Error: 168_373 - .saturating_add(Weight::from_parts(40_244_359, 0).saturating_mul(p.into())) + // Minimum execution time: 8_196_422_000 picoseconds. + Weight::from_parts(8_474_214_520, 5069931) + // Standard Error: 71_564 + .saturating_add(Weight::from_parts(41_738_666, 0).saturating_mul(p.into())) .saturating_add(RocksDbWeight::get().reads(2048_u64)) } /// The range of component `p` is `[0, 512]`. @@ -3120,10 +3124,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `1813 + p * (65580 ±0)` // Estimated: `1939 + p * (75482 ±0)` - // Minimum execution time: 97_303_000 picoseconds. - Weight::from_parts(98_185_000, 1939) - // Standard Error: 38_471 - .saturating_add(Weight::from_parts(55_016_921, 0).saturating_mul(p.into())) + // Minimum execution time: 93_446_000 picoseconds. + Weight::from_parts(96_664_000, 1939) + // Standard Error: 46_722 + .saturating_add(Weight::from_parts(55_567_620, 0).saturating_mul(p.into())) .saturating_add(RocksDbWeight::get().reads((4_u64).saturating_mul(p.into()))) .saturating_add(Weight::from_parts(0, 75482).saturating_mul(p.into())) } @@ -3132,10 +3136,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `141` // Estimated: `1131 + p * (9900 ±0)` - // Minimum execution time: 102_497_000 picoseconds. - Weight::from_parts(104_932_685, 1131) - // Standard Error: 78_974 - .saturating_add(Weight::from_parts(39_257_150, 0).saturating_mul(p.into())) + // Minimum execution time: 106_137_000 picoseconds. + Weight::from_parts(107_751_954, 1131) + // Standard Error: 71_200 + .saturating_add(Weight::from_parts(41_236_505, 0).saturating_mul(p.into())) .saturating_add(RocksDbWeight::get().reads((4_u64).saturating_mul(p.into()))) .saturating_add(Weight::from_parts(0, 9900).saturating_mul(p.into())) } @@ -3144,10 +3148,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `141` // Estimated: `1496 + p * (9883 ±2)` - // Minimum execution time: 612_308_000 picoseconds. - Weight::from_parts(642_079_999, 1496) - // Standard Error: 357_245 - .saturating_add(Weight::from_parts(46_518_860, 0).saturating_mul(p.into())) + // Minimum execution time: 758_237_000 picoseconds. + Weight::from_parts(760_351_083, 1496) + // Standard Error: 319_479 + .saturating_add(Weight::from_parts(53_277_303, 0).saturating_mul(p.into())) .saturating_add(RocksDbWeight::get().reads((4_u64).saturating_mul(p.into()))) .saturating_add(Weight::from_parts(0, 9883).saturating_mul(p.into())) } @@ -3156,10 +3160,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `141` // Estimated: `317931` - // Minimum execution time: 1_068_248_000 picoseconds. - Weight::from_parts(1_080_741_205, 317931) - // Standard Error: 262_216 - .saturating_add(Weight::from_parts(50_047_907, 0).saturating_mul(p.into())) + // Minimum execution time: 1_299_071_000 picoseconds. + Weight::from_parts(1_320_542_278, 317931) + // Standard Error: 364_770 + .saturating_add(Weight::from_parts(53_225_083, 0).saturating_mul(p.into())) .saturating_add(RocksDbWeight::get().reads(128_u64)) } /// The range of component `r` is `[0, 20]`. @@ -3167,303 +3171,303 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 3_099_000 picoseconds. - Weight::from_parts(6_340_084, 0) - // Standard Error: 180_257 - .saturating_add(Weight::from_parts(74_666_091, 0).saturating_mul(r.into())) + // Minimum execution time: 4_118_000 picoseconds. + Weight::from_parts(7_418_987, 0) + // Standard Error: 299_976 + .saturating_add(Weight::from_parts(77_036_564, 0).saturating_mul(r.into())) } /// The range of component `r` is `[50, 500]`. fn instr_i64load(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 4_391_547_000 picoseconds. - Weight::from_parts(4_140_785_425, 0) - // Standard Error: 89_369 - .saturating_add(Weight::from_parts(5_769_622, 0).saturating_mul(r.into())) + // Minimum execution time: 4_461_228_000 picoseconds. + Weight::from_parts(4_172_544_233, 0) + // Standard Error: 108_717 + .saturating_add(Weight::from_parts(5_492_504, 0).saturating_mul(r.into())) } /// The range of component `r` is `[50, 500]`. fn instr_i32load(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 4_386_802_000 picoseconds. - Weight::from_parts(4_243_536_456, 0) - // Standard Error: 95_210 - .saturating_add(Weight::from_parts(5_278_131, 0).saturating_mul(r.into())) + // Minimum execution time: 4_440_105_000 picoseconds. + Weight::from_parts(4_189_326_223, 0) + // Standard Error: 94_884 + .saturating_add(Weight::from_parts(5_283_060, 0).saturating_mul(r.into())) } /// The range of component `r` is `[50, 500]`. fn instr_i64store(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 11_072_272_000 picoseconds. - Weight::from_parts(11_558_306_225, 0) - // Standard Error: 165_659 - .saturating_add(Weight::from_parts(9_828_260, 0).saturating_mul(r.into())) + // Minimum execution time: 11_389_557_000 picoseconds. + Weight::from_parts(11_860_510_711, 0) + // Standard Error: 156_021 + .saturating_add(Weight::from_parts(9_199_358, 0).saturating_mul(r.into())) } /// The range of component `r` is `[50, 500]`. fn instr_i32store(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 10_285_071_000 picoseconds. - Weight::from_parts(11_137_621_942, 0) - // Standard Error: 147_513 - .saturating_add(Weight::from_parts(9_014_757, 0).saturating_mul(r.into())) + // Minimum execution time: 11_497_103_000 picoseconds. + Weight::from_parts(11_330_880_436, 0) + // Standard Error: 132_247 + .saturating_add(Weight::from_parts(10_016_516, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_select(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_285_000 picoseconds. - Weight::from_parts(2_410_000, 0) - // Standard Error: 7_624 - .saturating_add(Weight::from_parts(3_864_490, 0).saturating_mul(r.into())) + // Minimum execution time: 2_381_000 picoseconds. + Weight::from_parts(2_444_000, 0) + // Standard Error: 7_402 + .saturating_add(Weight::from_parts(3_876_295, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_if(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_342_000 picoseconds. - Weight::from_parts(2_433_000, 0) - // Standard Error: 6_413 - .saturating_add(Weight::from_parts(3_120_732, 0).saturating_mul(r.into())) + // Minimum execution time: 2_405_000 picoseconds. + Weight::from_parts(481_308, 0) + // Standard Error: 8_161 + .saturating_add(Weight::from_parts(3_159_957, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_br(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_301_000 picoseconds. - Weight::from_parts(3_591_730, 0) - // Standard Error: 1_106 - .saturating_add(Weight::from_parts(1_565_415, 0).saturating_mul(r.into())) + // Minimum execution time: 2_371_000 picoseconds. + Weight::from_parts(3_249_787, 0) + // Standard Error: 1_586 + .saturating_add(Weight::from_parts(1_582_965, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_br_if(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_306_000 picoseconds. - Weight::from_parts(2_461_000, 0) - // Standard Error: 7_711 - .saturating_add(Weight::from_parts(2_932_880, 0).saturating_mul(r.into())) + // Minimum execution time: 2_216_000 picoseconds. + Weight::from_parts(2_300_000, 0) + // Standard Error: 6_757 + .saturating_add(Weight::from_parts(2_971_649, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_br_table(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_358_000 picoseconds. - Weight::from_parts(2_144_801, 0) - // Standard Error: 22_082 - .saturating_add(Weight::from_parts(5_266_139, 0).saturating_mul(r.into())) + // Minimum execution time: 2_259_000 picoseconds. + Weight::from_parts(2_872_259, 0) + // Standard Error: 19_834 + .saturating_add(Weight::from_parts(5_176_111, 0).saturating_mul(r.into())) } /// The range of component `e` is `[1, 256]`. fn instr_br_table_per_entry(e: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 6_803_000 picoseconds. - Weight::from_parts(5_374_690, 0) - // Standard Error: 1_699 - .saturating_add(Weight::from_parts(171_193, 0).saturating_mul(e.into())) + // Minimum execution time: 6_999_000 picoseconds. + Weight::from_parts(6_015_140, 0) + // Standard Error: 1_903 + .saturating_add(Weight::from_parts(170_143, 0).saturating_mul(e.into())) } /// The range of component `r` is `[0, 50]`. fn instr_call_const(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_431_000 picoseconds. - Weight::from_parts(4_875_813, 0) - // Standard Error: 8_258 - .saturating_add(Weight::from_parts(2_629_733, 0).saturating_mul(r.into())) + // Minimum execution time: 2_308_000 picoseconds. + Weight::from_parts(5_881_148, 0) + // Standard Error: 9_069 + .saturating_add(Weight::from_parts(2_574_099, 0).saturating_mul(r.into())) } fn instr_i64const(r: u32, ) -> Weight { Weight::from_parts(0, 0) - .saturating_add(Weight::from_parts(2_629_733 - - 2_421_700, 0).saturating_mul(r.into())) + .saturating_add(Weight::from_parts(2_574_099 - + 2_423_093, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_call(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_403_000 picoseconds. - Weight::from_parts(5_140_243, 0) - // Standard Error: 13_164 - .saturating_add(Weight::from_parts(2_421_700, 0).saturating_mul(r.into())) + // Minimum execution time: 2_337_000 picoseconds. + Weight::from_parts(5_123_036, 0) + // Standard Error: 12_143 + .saturating_add(Weight::from_parts(2_423_093, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_call_indirect(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_669_000 picoseconds. - Weight::from_parts(22_369_265, 0) - // Standard Error: 28_577 - .saturating_add(Weight::from_parts(9_740_558, 0).saturating_mul(r.into())) + // Minimum execution time: 2_736_000 picoseconds. + Weight::from_parts(16_600_828, 0) + // Standard Error: 30_025 + .saturating_add(Weight::from_parts(10_214_913, 0).saturating_mul(r.into())) } /// The range of component `p` is `[0, 128]`. fn instr_call_indirect_per_param(p: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 12_277_000 picoseconds. - Weight::from_parts(3_596_853, 0) - // Standard Error: 5_869 - .saturating_add(Weight::from_parts(1_258_605, 0).saturating_mul(p.into())) + // Minimum execution time: 12_483_000 picoseconds. + Weight::from_parts(1_416_669, 0) + // Standard Error: 5_995 + .saturating_add(Weight::from_parts(1_336_453, 0).saturating_mul(p.into())) } /// The range of component `l` is `[0, 1024]`. fn instr_call_per_local(_l: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 5_391_000 picoseconds. - Weight::from_parts(5_778_137, 0) + // Minimum execution time: 5_497_000 picoseconds. + Weight::from_parts(5_981_231, 0) } /// The range of component `r` is `[0, 50]`. fn instr_local_get(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 4_835_000 picoseconds. - Weight::from_parts(6_065_483, 0) - // Standard Error: 3_006 - .saturating_add(Weight::from_parts(378_512, 0).saturating_mul(r.into())) + // Minimum execution time: 4_730_000 picoseconds. + Weight::from_parts(5_851_529, 0) + // Standard Error: 2_642 + .saturating_add(Weight::from_parts(392_869, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_local_set(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 4_722_000 picoseconds. - Weight::from_parts(3_902_309, 0) - // Standard Error: 5_742 - .saturating_add(Weight::from_parts(1_056_408, 0).saturating_mul(r.into())) + // Minimum execution time: 4_837_000 picoseconds. + Weight::from_parts(4_473_635, 0) + // Standard Error: 5_210 + .saturating_add(Weight::from_parts(1_003_312, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_local_tee(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 4_888_000 picoseconds. - Weight::from_parts(4_512_058, 0) - // Standard Error: 6_410 - .saturating_add(Weight::from_parts(1_001_510, 0).saturating_mul(r.into())) + // Minimum execution time: 4_802_000 picoseconds. + Weight::from_parts(2_153_776, 0) + // Standard Error: 11_517 + .saturating_add(Weight::from_parts(1_186_032, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_global_get(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 6_413_000 picoseconds. - Weight::from_parts(2_704_134, 0) - // Standard Error: 7_244 - .saturating_add(Weight::from_parts(804_200, 0).saturating_mul(r.into())) + // Minimum execution time: 6_375_000 picoseconds. + Weight::from_parts(3_754_449, 0) + // Standard Error: 5_686 + .saturating_add(Weight::from_parts(763_597, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_global_set(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 6_516_000 picoseconds. - Weight::from_parts(1_028_752, 0) - // Standard Error: 8_792 - .saturating_add(Weight::from_parts(1_494_630, 0).saturating_mul(r.into())) + // Minimum execution time: 6_475_000 picoseconds. + Weight::from_parts(266_670, 0) + // Standard Error: 10_193 + .saturating_add(Weight::from_parts(1_552_777, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_memory_current(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 5_560_000 picoseconds. - Weight::from_parts(1_126_442, 0) - // Standard Error: 14_476 - .saturating_add(Weight::from_parts(7_240_597, 0).saturating_mul(r.into())) + // Minimum execution time: 6_887_000 picoseconds. + Weight::from_parts(4_333_544, 0) + // Standard Error: 10_173 + .saturating_add(Weight::from_parts(6_952_830, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64clz(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_299_000 picoseconds. - Weight::from_parts(2_449_000, 0) - // Standard Error: 7_416 - .saturating_add(Weight::from_parts(3_344_387, 0).saturating_mul(r.into())) + // Minimum execution time: 2_267_000 picoseconds. + Weight::from_parts(2_351_000, 0) + // Standard Error: 5_280 + .saturating_add(Weight::from_parts(3_360_413, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32clz(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_389_000 picoseconds. - Weight::from_parts(2_551_000, 0) - // Standard Error: 5_708 - .saturating_add(Weight::from_parts(3_133_430, 0).saturating_mul(r.into())) + // Minimum execution time: 2_283_000 picoseconds. + Weight::from_parts(2_357_000, 0) + // Standard Error: 4_452 + .saturating_add(Weight::from_parts(3_099_489, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64ctz(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_428_000 picoseconds. - Weight::from_parts(2_511_000, 0) - // Standard Error: 7_262 - .saturating_add(Weight::from_parts(3_192_675, 0).saturating_mul(r.into())) + // Minimum execution time: 2_328_000 picoseconds. + Weight::from_parts(2_417_000, 0) + // Standard Error: 5_054 + .saturating_add(Weight::from_parts(3_106_996, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32ctz(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_333_000 picoseconds. - Weight::from_parts(2_426_000, 0) - // Standard Error: 4_554 - .saturating_add(Weight::from_parts(2_683_293, 0).saturating_mul(r.into())) + // Minimum execution time: 2_230_000 picoseconds. + Weight::from_parts(2_296_000, 0) + // Standard Error: 3_924 + .saturating_add(Weight::from_parts(2_681_831, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64popcnt(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_334_000 picoseconds. - Weight::from_parts(2_385_000, 0) - // Standard Error: 4_686 - .saturating_add(Weight::from_parts(631_609, 0).saturating_mul(r.into())) + // Minimum execution time: 2_294_000 picoseconds. + Weight::from_parts(2_438_000, 0) + // Standard Error: 4_198 + .saturating_add(Weight::from_parts(603_106, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32popcnt(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_356_000 picoseconds. - Weight::from_parts(1_221_890, 0) - // Standard Error: 3_960 - .saturating_add(Weight::from_parts(452_047, 0).saturating_mul(r.into())) + // Minimum execution time: 2_257_000 picoseconds. + Weight::from_parts(2_121_941, 0) + // Standard Error: 3_525 + .saturating_add(Weight::from_parts(401_578, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64eqz(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_318_000 picoseconds. - Weight::from_parts(2_390_000, 0) - // Standard Error: 11_114 - .saturating_add(Weight::from_parts(1_916_122, 0).saturating_mul(r.into())) + // Minimum execution time: 2_224_000 picoseconds. + Weight::from_parts(2_291_000, 0) + // Standard Error: 9_436 + .saturating_add(Weight::from_parts(1_891_725, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32eqz(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_436_000 picoseconds. - Weight::from_parts(2_504_000, 0) - // Standard Error: 7_104 - .saturating_add(Weight::from_parts(1_156_958, 0).saturating_mul(r.into())) + // Minimum execution time: 2_273_000 picoseconds. + Weight::from_parts(2_417_000, 0) + // Standard Error: 8_255 + .saturating_add(Weight::from_parts(1_289_311, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32extend8s(r: u32, ) -> Weight { @@ -3471,631 +3475,631 @@ impl WeightInfo for () { // Measured: `0` // Estimated: `0` // Minimum execution time: 2_276_000 picoseconds. - Weight::from_parts(1_708_596, 0) - // Standard Error: 2_843 - .saturating_add(Weight::from_parts(377_083, 0).saturating_mul(r.into())) + Weight::from_parts(1_306_236, 0) + // Standard Error: 5_275 + .saturating_add(Weight::from_parts(426_430, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32extend16s(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_386_000 picoseconds. - Weight::from_parts(1_424_415, 0) - // Standard Error: 3_599 - .saturating_add(Weight::from_parts(395_934, 0).saturating_mul(r.into())) + // Minimum execution time: 2_341_000 picoseconds. + Weight::from_parts(1_669_540, 0) + // Standard Error: 4_902 + .saturating_add(Weight::from_parts(405_099, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64extend8s(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_396_000 picoseconds. - Weight::from_parts(2_491_000, 0) - // Standard Error: 3_774 - .saturating_add(Weight::from_parts(516_281, 0).saturating_mul(r.into())) + // Minimum execution time: 2_244_000 picoseconds. + Weight::from_parts(2_317_000, 0) + // Standard Error: 3_916 + .saturating_add(Weight::from_parts(552_354, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64extend16s(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_308_000 picoseconds. - Weight::from_parts(548_192, 0) - // Standard Error: 4_583 - .saturating_add(Weight::from_parts(556_734, 0).saturating_mul(r.into())) + // Minimum execution time: 2_316_000 picoseconds. + Weight::from_parts(2_395_000, 0) + // Standard Error: 5_375 + .saturating_add(Weight::from_parts(589_608, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64extend32s(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_333_000 picoseconds. - Weight::from_parts(447_271, 0) - // Standard Error: 5_300 - .saturating_add(Weight::from_parts(535_915, 0).saturating_mul(r.into())) + // Minimum execution time: 2_258_000 picoseconds. + Weight::from_parts(98_911, 0) + // Standard Error: 7_257 + .saturating_add(Weight::from_parts(581_834, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64extendsi32(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_340_000 picoseconds. - Weight::from_parts(1_639_695, 0) - // Standard Error: 3_519 - .saturating_add(Weight::from_parts(368_523, 0).saturating_mul(r.into())) + // Minimum execution time: 2_293_000 picoseconds. + Weight::from_parts(1_730_402, 0) + // Standard Error: 4_194 + .saturating_add(Weight::from_parts(357_287, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64extendui32(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_305_000 picoseconds. - Weight::from_parts(2_843_474, 0) - // Standard Error: 1_950 - .saturating_add(Weight::from_parts(176_592, 0).saturating_mul(r.into())) + // Minimum execution time: 2_580_000 picoseconds. + Weight::from_parts(2_927_247, 0) + // Standard Error: 2_012 + .saturating_add(Weight::from_parts(181_106, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32wrapi64(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_351_000 picoseconds. - Weight::from_parts(2_894_613, 0) - // Standard Error: 2_024 - .saturating_add(Weight::from_parts(188_853, 0).saturating_mul(r.into())) + // Minimum execution time: 2_308_000 picoseconds. + Weight::from_parts(2_742_236, 0) + // Standard Error: 2_482 + .saturating_add(Weight::from_parts(187_830, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64eq(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_353_000 picoseconds. - Weight::from_parts(2_418_000, 0) - // Standard Error: 9_504 - .saturating_add(Weight::from_parts(1_936_605, 0).saturating_mul(r.into())) + // Minimum execution time: 2_324_000 picoseconds. + Weight::from_parts(2_385_000, 0) + // Standard Error: 9_154 + .saturating_add(Weight::from_parts(1_858_617, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32eq(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_291_000 picoseconds. - Weight::from_parts(2_364_000, 0) - // Standard Error: 8_346 - .saturating_add(Weight::from_parts(1_222_521, 0).saturating_mul(r.into())) + // Minimum execution time: 2_237_000 picoseconds. + Weight::from_parts(2_302_000, 0) + // Standard Error: 7_801 + .saturating_add(Weight::from_parts(1_226_411, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64ne(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_345_000 picoseconds. - Weight::from_parts(2_452_000, 0) - // Standard Error: 10_232 - .saturating_add(Weight::from_parts(1_883_867, 0).saturating_mul(r.into())) + // Minimum execution time: 2_265_000 picoseconds. + Weight::from_parts(2_358_000, 0) + // Standard Error: 9_102 + .saturating_add(Weight::from_parts(1_866_723, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32ne(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_323_000 picoseconds. - Weight::from_parts(2_387_000, 0) - // Standard Error: 7_581 - .saturating_add(Weight::from_parts(1_200_178, 0).saturating_mul(r.into())) + // Minimum execution time: 2_267_000 picoseconds. + Weight::from_parts(2_381_000, 0) + // Standard Error: 8_629 + .saturating_add(Weight::from_parts(1_209_968, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64lts(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_410_000 picoseconds. - Weight::from_parts(2_459_000, 0) - // Standard Error: 11_139 - .saturating_add(Weight::from_parts(1_877_766, 0).saturating_mul(r.into())) + // Minimum execution time: 2_274_000 picoseconds. + Weight::from_parts(2_330_000, 0) + // Standard Error: 9_193 + .saturating_add(Weight::from_parts(1_895_140, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32lts(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_273_000 picoseconds. - Weight::from_parts(2_387_000, 0) - // Standard Error: 8_083 - .saturating_add(Weight::from_parts(1_217_904, 0).saturating_mul(r.into())) + // Minimum execution time: 2_306_000 picoseconds. + Weight::from_parts(2_394_000, 0) + // Standard Error: 7_780 + .saturating_add(Weight::from_parts(1_209_776, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64ltu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_403_000 picoseconds. - Weight::from_parts(2_482_000, 0) - // Standard Error: 11_044 - .saturating_add(Weight::from_parts(1_956_302, 0).saturating_mul(r.into())) + // Minimum execution time: 2_273_000 picoseconds. + Weight::from_parts(2_395_000, 0) + // Standard Error: 8_868 + .saturating_add(Weight::from_parts(1_845_417, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32ltu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_353_000 picoseconds. - Weight::from_parts(2_420_000, 0) - // Standard Error: 7_870 - .saturating_add(Weight::from_parts(1_213_570, 0).saturating_mul(r.into())) + // Minimum execution time: 2_280_000 picoseconds. + Weight::from_parts(2_360_000, 0) + // Standard Error: 8_139 + .saturating_add(Weight::from_parts(1_208_611, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64gts(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_364_000 picoseconds. - Weight::from_parts(2_430_000, 0) - // Standard Error: 10_577 - .saturating_add(Weight::from_parts(1_968_043, 0).saturating_mul(r.into())) + // Minimum execution time: 2_299_000 picoseconds. + Weight::from_parts(2_335_000, 0) + // Standard Error: 8_008 + .saturating_add(Weight::from_parts(1_833_636, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32gts(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_328_000 picoseconds. - Weight::from_parts(2_442_000, 0) - // Standard Error: 7_838 - .saturating_add(Weight::from_parts(1_267_211, 0).saturating_mul(r.into())) + // Minimum execution time: 2_222_000 picoseconds. + Weight::from_parts(2_376_000, 0) + // Standard Error: 7_996 + .saturating_add(Weight::from_parts(1_224_203, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64gtu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_395_000 picoseconds. - Weight::from_parts(2_460_000, 0) - // Standard Error: 10_856 - .saturating_add(Weight::from_parts(1_910_357, 0).saturating_mul(r.into())) + // Minimum execution time: 2_371_000 picoseconds. + Weight::from_parts(2_421_000, 0) + // Standard Error: 9_119 + .saturating_add(Weight::from_parts(1_821_158, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32gtu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_343_000 picoseconds. - Weight::from_parts(2_409_000, 0) - // Standard Error: 5_786 - .saturating_add(Weight::from_parts(1_128_653, 0).saturating_mul(r.into())) + // Minimum execution time: 2_305_000 picoseconds. + Weight::from_parts(2_418_000, 0) + // Standard Error: 7_441 + .saturating_add(Weight::from_parts(1_186_995, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64les(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_318_000 picoseconds. - Weight::from_parts(2_433_000, 0) - // Standard Error: 10_344 - .saturating_add(Weight::from_parts(1_897_480, 0).saturating_mul(r.into())) + // Minimum execution time: 2_340_000 picoseconds. + Weight::from_parts(2_362_000, 0) + // Standard Error: 8_788 + .saturating_add(Weight::from_parts(1_811_701, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32les(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_355_000 picoseconds. - Weight::from_parts(2_460_000, 0) - // Standard Error: 6_963 - .saturating_add(Weight::from_parts(1_125_698, 0).saturating_mul(r.into())) + // Minimum execution time: 2_352_000 picoseconds. + Weight::from_parts(2_431_000, 0) + // Standard Error: 6_620 + .saturating_add(Weight::from_parts(1_171_906, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64leu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_356_000 picoseconds. - Weight::from_parts(2_447_000, 0) - // Standard Error: 8_285 - .saturating_add(Weight::from_parts(1_848_149, 0).saturating_mul(r.into())) + // Minimum execution time: 2_352_000 picoseconds. + Weight::from_parts(2_380_000, 0) + // Standard Error: 8_554 + .saturating_add(Weight::from_parts(1_821_955, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32leu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_327_000 picoseconds. - Weight::from_parts(2_394_000, 0) - // Standard Error: 7_282 - .saturating_add(Weight::from_parts(1_176_423, 0).saturating_mul(r.into())) + // Minimum execution time: 2_299_000 picoseconds. + Weight::from_parts(2_389_000, 0) + // Standard Error: 7_710 + .saturating_add(Weight::from_parts(1_188_722, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64ges(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_372_000 picoseconds. - Weight::from_parts(2_439_000, 0) - // Standard Error: 9_207 - .saturating_add(Weight::from_parts(1_837_009, 0).saturating_mul(r.into())) + // Minimum execution time: 2_325_000 picoseconds. + Weight::from_parts(2_387_000, 0) + // Standard Error: 10_150 + .saturating_add(Weight::from_parts(1_912_877, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32ges(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_368_000 picoseconds. - Weight::from_parts(2_427_000, 0) - // Standard Error: 8_320 - .saturating_add(Weight::from_parts(1_231_088, 0).saturating_mul(r.into())) + // Minimum execution time: 2_377_000 picoseconds. + Weight::from_parts(2_423_000, 0) + // Standard Error: 6_824 + .saturating_add(Weight::from_parts(1_181_831, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64geu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_373_000 picoseconds. - Weight::from_parts(2_461_000, 0) - // Standard Error: 9_499 - .saturating_add(Weight::from_parts(1_922_588, 0).saturating_mul(r.into())) + // Minimum execution time: 2_292_000 picoseconds. + Weight::from_parts(2_384_000, 0) + // Standard Error: 9_214 + .saturating_add(Weight::from_parts(1_842_825, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32geu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_387_000 picoseconds. - Weight::from_parts(2_455_000, 0) - // Standard Error: 7_681 - .saturating_add(Weight::from_parts(1_198_894, 0).saturating_mul(r.into())) + // Minimum execution time: 2_283_000 picoseconds. + Weight::from_parts(2_344_000, 0) + // Standard Error: 7_145 + .saturating_add(Weight::from_parts(1_216_207, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64add(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_308_000 picoseconds. - Weight::from_parts(2_389_000, 0) - // Standard Error: 7_797 - .saturating_add(Weight::from_parts(1_286_566, 0).saturating_mul(r.into())) + // Minimum execution time: 2_232_000 picoseconds. + Weight::from_parts(2_391_000, 0) + // Standard Error: 9_159 + .saturating_add(Weight::from_parts(1_360_135, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32add(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_329_000 picoseconds. - Weight::from_parts(2_389_000, 0) - // Standard Error: 4_968 - .saturating_add(Weight::from_parts(645_254, 0).saturating_mul(r.into())) + // Minimum execution time: 2_279_000 picoseconds. + Weight::from_parts(2_379_000, 0) + // Standard Error: 5_400 + .saturating_add(Weight::from_parts(704_012, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64sub(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_409_000 picoseconds. - Weight::from_parts(2_489_000, 0) - // Standard Error: 7_055 - .saturating_add(Weight::from_parts(1_232_084, 0).saturating_mul(r.into())) + // Minimum execution time: 2_355_000 picoseconds. + Weight::from_parts(2_402_000, 0) + // Standard Error: 8_632 + .saturating_add(Weight::from_parts(1_358_130, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32sub(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_371_000 picoseconds. - Weight::from_parts(2_420_000, 0) - // Standard Error: 4_348 - .saturating_add(Weight::from_parts(633_810, 0).saturating_mul(r.into())) + // Minimum execution time: 2_365_000 picoseconds. + Weight::from_parts(2_389_000, 0) + // Standard Error: 4_840 + .saturating_add(Weight::from_parts(658_882, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64mul(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_336_000 picoseconds. - Weight::from_parts(2_413_000, 0) - // Standard Error: 8_202 - .saturating_add(Weight::from_parts(1_777_425, 0).saturating_mul(r.into())) + // Minimum execution time: 2_209_000 picoseconds. + Weight::from_parts(2_324_000, 0) + // Standard Error: 8_679 + .saturating_add(Weight::from_parts(1_840_263, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32mul(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_314_000 picoseconds. - Weight::from_parts(2_369_000, 0) - // Standard Error: 6_935 - .saturating_add(Weight::from_parts(1_201_570, 0).saturating_mul(r.into())) + // Minimum execution time: 2_258_000 picoseconds. + Weight::from_parts(2_382_000, 0) + // Standard Error: 7_484 + .saturating_add(Weight::from_parts(1_255_185, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64divs(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_276_000 picoseconds. - Weight::from_parts(6_846_840, 0) - // Standard Error: 17_822 - .saturating_add(Weight::from_parts(2_268_370, 0).saturating_mul(r.into())) + // Minimum execution time: 2_369_000 picoseconds. + Weight::from_parts(6_412_885, 0) + // Standard Error: 22_130 + .saturating_add(Weight::from_parts(2_376_785, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32divs(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_394_000 picoseconds. - Weight::from_parts(4_704_336, 0) - // Standard Error: 10_960 - .saturating_add(Weight::from_parts(2_182_711, 0).saturating_mul(r.into())) + // Minimum execution time: 2_266_000 picoseconds. + Weight::from_parts(2_981_330, 0) + // Standard Error: 11_996 + .saturating_add(Weight::from_parts(2_322_763, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64divu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_375_000 picoseconds. - Weight::from_parts(1_968_824, 0) - // Standard Error: 15_899 - .saturating_add(Weight::from_parts(2_762_269, 0).saturating_mul(r.into())) + // Minimum execution time: 2_240_000 picoseconds. + Weight::from_parts(7_628_007, 0) + // Standard Error: 29_510 + .saturating_add(Weight::from_parts(2_483_957, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32divu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_335_000 picoseconds. - Weight::from_parts(1_450_000, 0) - // Standard Error: 13_496 - .saturating_add(Weight::from_parts(2_401_407, 0).saturating_mul(r.into())) + // Minimum execution time: 2_387_000 picoseconds. + Weight::from_parts(4_910_027, 0) + // Standard Error: 23_548 + .saturating_add(Weight::from_parts(2_233_487, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64rems(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_448_000 picoseconds. - Weight::from_parts(2_513_000, 0) - // Standard Error: 19_401 - .saturating_add(Weight::from_parts(9_309_211, 0).saturating_mul(r.into())) + // Minimum execution time: 2_297_000 picoseconds. + Weight::from_parts(16_240_633, 0) + // Standard Error: 67_100 + .saturating_add(Weight::from_parts(8_506_720, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32rems(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_273_000 picoseconds. - Weight::from_parts(1_738_370, 0) - // Standard Error: 42_672 - .saturating_add(Weight::from_parts(7_512_557, 0).saturating_mul(r.into())) + // Minimum execution time: 2_234_000 picoseconds. + Weight::from_parts(2_498_693, 0) + // Standard Error: 48_996 + .saturating_add(Weight::from_parts(7_513_162, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64remu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_371_000 picoseconds. - Weight::from_parts(2_215_088, 0) - // Standard Error: 15_445 - .saturating_add(Weight::from_parts(2_956_278, 0).saturating_mul(r.into())) + // Minimum execution time: 2_221_000 picoseconds. + Weight::from_parts(5_074_264, 0) + // Standard Error: 23_109 + .saturating_add(Weight::from_parts(2_727_269, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32remu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_409_000 picoseconds. - Weight::from_parts(217_500, 0) - // Standard Error: 7_904 - .saturating_add(Weight::from_parts(2_576_151, 0).saturating_mul(r.into())) + // Minimum execution time: 2_283_000 picoseconds. + Weight::from_parts(2_057_554, 0) + // Standard Error: 15_404 + .saturating_add(Weight::from_parts(2_428_553, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64and(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_456_000 picoseconds. - Weight::from_parts(2_503_000, 0) - // Standard Error: 7_920 - .saturating_add(Weight::from_parts(1_321_543, 0).saturating_mul(r.into())) + // Minimum execution time: 2_250_000 picoseconds. + Weight::from_parts(2_359_000, 0) + // Standard Error: 8_133 + .saturating_add(Weight::from_parts(1_333_125, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32and(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_346_000 picoseconds. - Weight::from_parts(2_479_000, 0) - // Standard Error: 4_711 - .saturating_add(Weight::from_parts(689_892, 0).saturating_mul(r.into())) + // Minimum execution time: 2_251_000 picoseconds. + Weight::from_parts(2_372_000, 0) + // Standard Error: 4_205 + .saturating_add(Weight::from_parts(671_074, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64or(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_339_000 picoseconds. - Weight::from_parts(2_427_000, 0) - // Standard Error: 8_029 - .saturating_add(Weight::from_parts(1_256_838, 0).saturating_mul(r.into())) + // Minimum execution time: 2_257_000 picoseconds. + Weight::from_parts(2_323_000, 0) + // Standard Error: 7_098 + .saturating_add(Weight::from_parts(1_323_703, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32or(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_334_000 picoseconds. - Weight::from_parts(2_480_000, 0) - // Standard Error: 3_812 - .saturating_add(Weight::from_parts(607_420, 0).saturating_mul(r.into())) + // Minimum execution time: 2_247_000 picoseconds. + Weight::from_parts(2_372_000, 0) + // Standard Error: 6_649 + .saturating_add(Weight::from_parts(695_117, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64xor(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_328_000 picoseconds. - Weight::from_parts(2_392_000, 0) - // Standard Error: 7_362 - .saturating_add(Weight::from_parts(1_248_739, 0).saturating_mul(r.into())) + // Minimum execution time: 2_293_000 picoseconds. + Weight::from_parts(2_347_000, 0) + // Standard Error: 7_359 + .saturating_add(Weight::from_parts(1_355_885, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32xor(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_419_000 picoseconds. - Weight::from_parts(2_465_000, 0) - // Standard Error: 4_304 - .saturating_add(Weight::from_parts(604_813, 0).saturating_mul(r.into())) + // Minimum execution time: 2_239_000 picoseconds. + Weight::from_parts(2_335_000, 0) + // Standard Error: 4_076 + .saturating_add(Weight::from_parts(658_834, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64shl(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_298_000 picoseconds. - Weight::from_parts(2_433_000, 0) - // Standard Error: 8_043 - .saturating_add(Weight::from_parts(1_073_194, 0).saturating_mul(r.into())) + // Minimum execution time: 2_376_000 picoseconds. + Weight::from_parts(2_444_000, 0) + // Standard Error: 6_850 + .saturating_add(Weight::from_parts(1_191_253, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32shl(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_427_000 picoseconds. - Weight::from_parts(2_511_000, 0) - // Standard Error: 4_969 - .saturating_add(Weight::from_parts(594_802, 0).saturating_mul(r.into())) + // Minimum execution time: 2_240_000 picoseconds. + Weight::from_parts(2_310_000, 0) + // Standard Error: 4_398 + .saturating_add(Weight::from_parts(597_162, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64shrs(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_312_000 picoseconds. - Weight::from_parts(2_399_000, 0) - // Standard Error: 7_093 - .saturating_add(Weight::from_parts(1_110_114, 0).saturating_mul(r.into())) + // Minimum execution time: 2_338_000 picoseconds. + Weight::from_parts(2_421_000, 0) + // Standard Error: 8_320 + .saturating_add(Weight::from_parts(1_163_071, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32shrs(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_331_000 picoseconds. - Weight::from_parts(2_433_000, 0) - // Standard Error: 4_140 - .saturating_add(Weight::from_parts(600_354, 0).saturating_mul(r.into())) + // Minimum execution time: 2_376_000 picoseconds. + Weight::from_parts(2_464_000, 0) + // Standard Error: 5_750 + .saturating_add(Weight::from_parts(613_283, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64shru(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_300_000 picoseconds. - Weight::from_parts(2_419_000, 0) - // Standard Error: 7_150 - .saturating_add(Weight::from_parts(1_154_649, 0).saturating_mul(r.into())) + // Minimum execution time: 2_338_000 picoseconds. + Weight::from_parts(2_378_000, 0) + // Standard Error: 7_893 + .saturating_add(Weight::from_parts(1_161_655, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32shru(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_356_000 picoseconds. - Weight::from_parts(2_423_000, 0) - // Standard Error: 5_067 - .saturating_add(Weight::from_parts(594_487, 0).saturating_mul(r.into())) + // Minimum execution time: 2_260_000 picoseconds. + Weight::from_parts(2_351_000, 0) + // Standard Error: 3_972 + .saturating_add(Weight::from_parts(605_013, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64rotl(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_339_000 picoseconds. - Weight::from_parts(2_406_000, 0) - // Standard Error: 5_674 - .saturating_add(Weight::from_parts(1_051_819, 0).saturating_mul(r.into())) + // Minimum execution time: 2_324_000 picoseconds. + Weight::from_parts(2_375_000, 0) + // Standard Error: 7_329 + .saturating_add(Weight::from_parts(1_108_542, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32rotl(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_383_000 picoseconds. - Weight::from_parts(114_723, 0) - // Standard Error: 5_881 - .saturating_add(Weight::from_parts(646_798, 0).saturating_mul(r.into())) + // Minimum execution time: 2_342_000 picoseconds. + Weight::from_parts(2_465_000, 0) + // Standard Error: 5_553 + .saturating_add(Weight::from_parts(617_389, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64rotr(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_292_000 picoseconds. - Weight::from_parts(2_422_000, 0) - // Standard Error: 6_697 - .saturating_add(Weight::from_parts(1_053_580, 0).saturating_mul(r.into())) + // Minimum execution time: 2_260_000 picoseconds. + Weight::from_parts(2_419_000, 0) + // Standard Error: 8_448 + .saturating_add(Weight::from_parts(1_105_239, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32rotr(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_325_000 picoseconds. - Weight::from_parts(206_699, 0) - // Standard Error: 5_851 - .saturating_add(Weight::from_parts(639_333, 0).saturating_mul(r.into())) + // Minimum execution time: 2_255_000 picoseconds. + Weight::from_parts(2_321_000, 0) + // Standard Error: 5_862 + .saturating_add(Weight::from_parts(626_497, 0).saturating_mul(r.into())) } fn tasks_remove_resume_session() -> Weight { // Proof Size summary in bytes: // Measured: `352` // Estimated: `4169` - // Minimum execution time: 5_698_000 picoseconds. - Weight::from_parts(5_953_000, 4169) + // Minimum execution time: 5_780_000 picoseconds. + Weight::from_parts(6_083_000, 4169) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) } fn tasks_remove_gas_reservation() -> Weight { // Proof Size summary in bytes: - // Measured: `1003` - // Estimated: `23637` - // Minimum execution time: 61_615_000 picoseconds. - Weight::from_parts(64_309_000, 23637) + // Measured: `1039` + // Estimated: `23781` + // Minimum execution time: 62_100_000 picoseconds. + Weight::from_parts(64_771_000, 23781) .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().writes(6_u64)) } fn tasks_send_user_message_to_mailbox() -> Weight { // Proof Size summary in bytes: - // Measured: `784` - // Estimated: `21534` - // Minimum execution time: 43_449_000 picoseconds. - Weight::from_parts(44_990_000, 21534) + // Measured: `820` + // Estimated: `21750` + // Minimum execution time: 47_415_000 picoseconds. + Weight::from_parts(48_906_000, 21750) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().writes(5_u64)) } fn tasks_send_user_message() -> Weight { // Proof Size summary in bytes: - // Measured: `906` - // Estimated: `33891` - // Minimum execution time: 75_764_000 picoseconds. - Weight::from_parts(77_875_000, 33891) + // Measured: `942` + // Estimated: `34143` + // Minimum execution time: 76_882_000 picoseconds. + Weight::from_parts(79_728_000, 34143) .saturating_add(RocksDbWeight::get().reads(11_u64)) .saturating_add(RocksDbWeight::get().writes(10_u64)) } fn tasks_send_dispatch() -> Weight { // Proof Size summary in bytes: - // Measured: `591` - // Estimated: `19885` - // Minimum execution time: 31_362_000 picoseconds. - Weight::from_parts(32_425_000, 19885) + // Measured: `627` + // Estimated: `20101` + // Minimum execution time: 32_342_000 picoseconds. + Weight::from_parts(33_851_000, 20101) .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().writes(6_u64)) } fn tasks_wake_message() -> Weight { // Proof Size summary in bytes: - // Measured: `872` - // Estimated: `25908` - // Minimum execution time: 45_023_000 picoseconds. - Weight::from_parts(46_479_000, 25908) + // Measured: `908` + // Estimated: `26160` + // Minimum execution time: 50_697_000 picoseconds. + Weight::from_parts(53_632_000, 26160) .saturating_add(RocksDbWeight::get().reads(8_u64)) .saturating_add(RocksDbWeight::get().writes(6_u64)) } @@ -4103,37 +4107,37 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `80` // Estimated: `3545` - // Minimum execution time: 3_365_000 picoseconds. - Weight::from_parts(3_639_000, 3545) + // Minimum execution time: 3_467_000 picoseconds. + Weight::from_parts(3_690_000, 3545) .saturating_add(RocksDbWeight::get().reads(1_u64)) } fn tasks_remove_from_waitlist() -> Weight { // Proof Size summary in bytes: - // Measured: `1522` - // Estimated: `57192` - // Minimum execution time: 114_023_000 picoseconds. - Weight::from_parts(117_157_000, 57192) + // Measured: `1558` + // Estimated: `57552` + // Minimum execution time: 111_822_000 picoseconds. + Weight::from_parts(115_245_000, 57552) .saturating_add(RocksDbWeight::get().reads(16_u64)) .saturating_add(RocksDbWeight::get().writes(13_u64)) } fn tasks_remove_from_mailbox() -> Weight { // Proof Size summary in bytes: - // Measured: `1228` - // Estimated: `46026` - // Minimum execution time: 90_320_000 picoseconds. - Weight::from_parts(93_096_000, 46026) + // Measured: `1264` + // Estimated: `46350` + // Minimum execution time: 92_407_000 picoseconds. + Weight::from_parts(95_840_000, 46350) .saturating_add(RocksDbWeight::get().reads(14_u64)) .saturating_add(RocksDbWeight::get().writes(13_u64)) } /// The range of component `c` is `[0, 2044]`. fn tasks_pause_program(c: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `2200 + c * (16400 ±0)` - // Estimated: `19363 + c * (84480 ±0)` - // Minimum execution time: 28_326_000 picoseconds. - Weight::from_parts(28_612_000, 19363) - // Standard Error: 73_191 - .saturating_add(Weight::from_parts(39_403_570, 0).saturating_mul(c.into())) + // Measured: `2236 + c * (16400 ±0)` + // Estimated: `19543 + c * (84480 ±0)` + // Minimum execution time: 29_880_000 picoseconds. + Weight::from_parts(30_555_000, 19543) + // Standard Error: 65_806 + .saturating_add(Weight::from_parts(39_128_234, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(4_u64)) .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(c.into()))) .saturating_add(RocksDbWeight::get().writes(2_u64)) @@ -4143,12 +4147,12 @@ impl WeightInfo for () { /// The range of component `c` is `[0, 2044]`. fn tasks_pause_program_uninited(c: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `3025 + c * (42 ±0)` - // Estimated: `59431 + c * (2947 ±0)` - // Minimum execution time: 86_517_000 picoseconds. - Weight::from_parts(78_047_954, 59431) - // Standard Error: 2_660 - .saturating_add(Weight::from_parts(1_060_607, 0).saturating_mul(c.into())) + // Measured: `3061 + c * (42 ±0)` + // Estimated: `59827 + c * (2947 ±0)` + // Minimum execution time: 89_781_000 picoseconds. + Weight::from_parts(109_193_287, 59827) + // Standard Error: 2_877 + .saturating_add(Weight::from_parts(1_067_792, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(13_u64)) .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(c.into()))) .saturating_add(RocksDbWeight::get().writes(9_u64)) diff --git a/runtime/gear/src/tests.rs b/runtime/gear/src/tests.rs index fdac76f2217..c3ee466a2d6 100644 --- a/runtime/gear/src/tests.rs +++ b/runtime/gear/src/tests.rs @@ -141,7 +141,7 @@ fn page_costs_heuristic_test() { lazy_pages_signal_write_after_read: 9_500_000.into(), lazy_pages_host_func_read: 29_000_000.into(), lazy_pages_host_func_write: 33_000_000.into(), - lazy_pages_host_func_write_after_read: 9_245_597.into(), + lazy_pages_host_func_write_after_read: 10_700_000.into(), load_page_data: 9_700_000.into(), upload_page_data: 104_000_000.into(), static_page: 100.into(), diff --git a/runtime/gear/src/weights/frame_system.rs b/runtime/gear/src/weights/frame_system.rs index 31dd34692d1..3cd2ae74282 100644 --- a/runtime/gear/src/weights/frame_system.rs +++ b/runtime/gear/src/weights/frame_system.rs @@ -19,13 +19,13 @@ //! Autogenerated weights for frame_system //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-09-11, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-09-28, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` //! CPU: `Intel(R) Xeon(R) Platinum 8375C CPU @ 2.90GHz` -//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("vara-dev"), DB CACHE: 1024 +//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("gear-dev"), DB CACHE: 1024 // Executed Command: -// ./target/production/gear benchmark pallet --chain=vara-dev --steps=50 --repeat=20 --pallet=frame_system --extrinsic=* --execution=wasm --wasm-execution=compiled --heap-pages=4096 --output=./scripts/benchmarking/weights-output/frame_system.rs --template=.maintain/frame-weight-template.hbs +// ./target/production/gear benchmark pallet --chain=gear-dev --steps=50 --repeat=20 --pallet=frame_system --extrinsic=* --execution=wasm --wasm-execution=compiled --heap-pages=4096 --output=./scripts/benchmarking/weights-output/frame_system.rs --template=.maintain/frame-weight-template.hbs #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(unused_parens)] @@ -53,27 +53,27 @@ impl frame_system::WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_562_000 picoseconds. - Weight::from_parts(1_066_991, 0) + // Minimum execution time: 1_718_000 picoseconds. + Weight::from_parts(1_167_483, 0) // Standard Error: 0 - .saturating_add(Weight::from_parts(461, 0).saturating_mul(b.into())) + .saturating_add(Weight::from_parts(460, 0).saturating_mul(b.into())) } /// The range of component `b` is `[0, 1310720]`. fn remark_with_event(b: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 5_949_000 picoseconds. - Weight::from_parts(6_153_000, 0) + // Minimum execution time: 6_244_000 picoseconds. + Weight::from_parts(6_378_000, 0) // Standard Error: 0 - .saturating_add(Weight::from_parts(1_441, 0).saturating_mul(b.into())) + .saturating_add(Weight::from_parts(1_432, 0).saturating_mul(b.into())) } fn set_heap_pages() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `1485` - // Minimum execution time: 3_113_000 picoseconds. - Weight::from_parts(3_394_000, 1485) + // Minimum execution time: 3_227_000 picoseconds. + Weight::from_parts(3_417_000, 1485) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) } @@ -82,10 +82,10 @@ impl frame_system::WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_578_000 picoseconds. - Weight::from_parts(1_632_000, 0) - // Standard Error: 994 - .saturating_add(Weight::from_parts(687_989, 0).saturating_mul(i.into())) + // Minimum execution time: 1_736_000 picoseconds. + Weight::from_parts(1_802_000, 0) + // Standard Error: 891 + .saturating_add(Weight::from_parts(687_558, 0).saturating_mul(i.into())) .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(i.into()))) } /// The range of component `i` is `[0, 1000]`. @@ -93,21 +93,21 @@ impl frame_system::WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_593_000 picoseconds. - Weight::from_parts(1_667_000, 0) - // Standard Error: 783 - .saturating_add(Weight::from_parts(535_872, 0).saturating_mul(i.into())) + // Minimum execution time: 1_660_000 picoseconds. + Weight::from_parts(1_742_000, 0) + // Standard Error: 793 + .saturating_add(Weight::from_parts(525_505, 0).saturating_mul(i.into())) .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(i.into()))) } /// The range of component `p` is `[0, 1000]`. fn kill_prefix(p: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `82 + p * (69 ±0)` - // Estimated: `89 + p * (70 ±0)` - // Minimum execution time: 3_345_000 picoseconds. - Weight::from_parts(3_470_000, 89) - // Standard Error: 1_511 - .saturating_add(Weight::from_parts(1_126_865, 0).saturating_mul(p.into())) + // Measured: `70 + p * (69 ±0)` + // Estimated: `73 + p * (70 ±0)` + // Minimum execution time: 3_380_000 picoseconds. + Weight::from_parts(3_486_000, 73) + // Standard Error: 1_481 + .saturating_add(Weight::from_parts(1_131_430, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(p.into()))) .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(p.into()))) .saturating_add(Weight::from_parts(0, 70).saturating_mul(p.into())) @@ -121,27 +121,27 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_562_000 picoseconds. - Weight::from_parts(1_066_991, 0) + // Minimum execution time: 1_718_000 picoseconds. + Weight::from_parts(1_167_483, 0) // Standard Error: 0 - .saturating_add(Weight::from_parts(461, 0).saturating_mul(b.into())) + .saturating_add(Weight::from_parts(460, 0).saturating_mul(b.into())) } /// The range of component `b` is `[0, 1310720]`. fn remark_with_event(b: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 5_949_000 picoseconds. - Weight::from_parts(6_153_000, 0) + // Minimum execution time: 6_244_000 picoseconds. + Weight::from_parts(6_378_000, 0) // Standard Error: 0 - .saturating_add(Weight::from_parts(1_441, 0).saturating_mul(b.into())) + .saturating_add(Weight::from_parts(1_432, 0).saturating_mul(b.into())) } fn set_heap_pages() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `1485` - // Minimum execution time: 3_113_000 picoseconds. - Weight::from_parts(3_394_000, 1485) + // Minimum execution time: 3_227_000 picoseconds. + Weight::from_parts(3_417_000, 1485) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) } @@ -150,10 +150,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_578_000 picoseconds. - Weight::from_parts(1_632_000, 0) - // Standard Error: 994 - .saturating_add(Weight::from_parts(687_989, 0).saturating_mul(i.into())) + // Minimum execution time: 1_736_000 picoseconds. + Weight::from_parts(1_802_000, 0) + // Standard Error: 891 + .saturating_add(Weight::from_parts(687_558, 0).saturating_mul(i.into())) .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(i.into()))) } /// The range of component `i` is `[0, 1000]`. @@ -161,21 +161,21 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_593_000 picoseconds. - Weight::from_parts(1_667_000, 0) - // Standard Error: 783 - .saturating_add(Weight::from_parts(535_872, 0).saturating_mul(i.into())) + // Minimum execution time: 1_660_000 picoseconds. + Weight::from_parts(1_742_000, 0) + // Standard Error: 793 + .saturating_add(Weight::from_parts(525_505, 0).saturating_mul(i.into())) .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(i.into()))) } /// The range of component `p` is `[0, 1000]`. fn kill_prefix(p: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `82 + p * (69 ±0)` - // Estimated: `89 + p * (70 ±0)` - // Minimum execution time: 3_345_000 picoseconds. - Weight::from_parts(3_470_000, 89) - // Standard Error: 1_511 - .saturating_add(Weight::from_parts(1_126_865, 0).saturating_mul(p.into())) + // Measured: `70 + p * (69 ±0)` + // Estimated: `73 + p * (70 ±0)` + // Minimum execution time: 3_380_000 picoseconds. + Weight::from_parts(3_486_000, 73) + // Standard Error: 1_481 + .saturating_add(Weight::from_parts(1_131_430, 0).saturating_mul(p.into())) .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(p.into()))) .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(p.into()))) .saturating_add(Weight::from_parts(0, 70).saturating_mul(p.into())) diff --git a/runtime/gear/src/weights/pallet_balances.rs b/runtime/gear/src/weights/pallet_balances.rs index f096d50de43..7663008fa87 100644 --- a/runtime/gear/src/weights/pallet_balances.rs +++ b/runtime/gear/src/weights/pallet_balances.rs @@ -19,13 +19,13 @@ //! Autogenerated weights for pallet_balances //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-09-11, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-09-28, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` //! CPU: `Intel(R) Xeon(R) Platinum 8375C CPU @ 2.90GHz` -//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("vara-dev"), DB CACHE: 1024 +//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("gear-dev"), DB CACHE: 1024 // Executed Command: -// ./target/production/gear benchmark pallet --chain=vara-dev --steps=50 --repeat=20 --pallet=pallet_balances --extrinsic=* --execution=wasm --wasm-execution=compiled --heap-pages=4096 --output=./scripts/benchmarking/weights-output/pallet_balances.rs --template=.maintain/frame-weight-template.hbs +// ./target/production/gear benchmark pallet --chain=gear-dev --steps=50 --repeat=20 --pallet=pallet_balances --extrinsic=* --execution=wasm --wasm-execution=compiled --heap-pages=4096 --output=./scripts/benchmarking/weights-output/pallet_balances.rs --template=.maintain/frame-weight-template.hbs #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(unused_parens)] @@ -53,8 +53,8 @@ impl pallet_balances::WeightInfo for SubstrateWeight // Proof Size summary in bytes: // Measured: `0` // Estimated: `3593` - // Minimum execution time: 29_789_000 picoseconds. - Weight::from_parts(30_683_000, 3593) + // Minimum execution time: 29_973_000 picoseconds. + Weight::from_parts(30_964_000, 3593) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -62,8 +62,8 @@ impl pallet_balances::WeightInfo for SubstrateWeight // Proof Size summary in bytes: // Measured: `0` // Estimated: `3593` - // Minimum execution time: 21_425_000 picoseconds. - Weight::from_parts(21_900_000, 3593) + // Minimum execution time: 21_364_000 picoseconds. + Weight::from_parts(21_759_000, 3593) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -71,8 +71,8 @@ impl pallet_balances::WeightInfo for SubstrateWeight // Proof Size summary in bytes: // Measured: `103` // Estimated: `3593` - // Minimum execution time: 12_387_000 picoseconds. - Weight::from_parts(12_754_000, 3593) + // Minimum execution time: 12_571_000 picoseconds. + Weight::from_parts(12_903_000, 3593) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -80,8 +80,8 @@ impl pallet_balances::WeightInfo for SubstrateWeight // Proof Size summary in bytes: // Measured: `103` // Estimated: `3593` - // Minimum execution time: 15_196_000 picoseconds. - Weight::from_parts(15_778_000, 3593) + // Minimum execution time: 15_846_000 picoseconds. + Weight::from_parts(16_097_000, 3593) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -89,8 +89,8 @@ impl pallet_balances::WeightInfo for SubstrateWeight // Proof Size summary in bytes: // Measured: `103` // Estimated: `6196` - // Minimum execution time: 31_544_000 picoseconds. - Weight::from_parts(32_018_000, 6196) + // Minimum execution time: 31_127_000 picoseconds. + Weight::from_parts(31_645_000, 6196) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) } @@ -98,8 +98,8 @@ impl pallet_balances::WeightInfo for SubstrateWeight // Proof Size summary in bytes: // Measured: `0` // Estimated: `3593` - // Minimum execution time: 28_027_000 picoseconds. - Weight::from_parts(29_047_000, 3593) + // Minimum execution time: 27_627_000 picoseconds. + Weight::from_parts(28_344_000, 3593) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -107,8 +107,8 @@ impl pallet_balances::WeightInfo for SubstrateWeight // Proof Size summary in bytes: // Measured: `103` // Estimated: `3593` - // Minimum execution time: 11_796_000 picoseconds. - Weight::from_parts(12_239_000, 3593) + // Minimum execution time: 12_036_000 picoseconds. + Weight::from_parts(12_609_000, 3593) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -120,8 +120,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `3593` - // Minimum execution time: 29_789_000 picoseconds. - Weight::from_parts(30_683_000, 3593) + // Minimum execution time: 29_973_000 picoseconds. + Weight::from_parts(30_964_000, 3593) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -129,8 +129,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `3593` - // Minimum execution time: 21_425_000 picoseconds. - Weight::from_parts(21_900_000, 3593) + // Minimum execution time: 21_364_000 picoseconds. + Weight::from_parts(21_759_000, 3593) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -138,8 +138,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `103` // Estimated: `3593` - // Minimum execution time: 12_387_000 picoseconds. - Weight::from_parts(12_754_000, 3593) + // Minimum execution time: 12_571_000 picoseconds. + Weight::from_parts(12_903_000, 3593) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -147,8 +147,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `103` // Estimated: `3593` - // Minimum execution time: 15_196_000 picoseconds. - Weight::from_parts(15_778_000, 3593) + // Minimum execution time: 15_846_000 picoseconds. + Weight::from_parts(16_097_000, 3593) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -156,8 +156,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `103` // Estimated: `6196` - // Minimum execution time: 31_544_000 picoseconds. - Weight::from_parts(32_018_000, 6196) + // Minimum execution time: 31_127_000 picoseconds. + Weight::from_parts(31_645_000, 6196) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) } @@ -165,8 +165,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `3593` - // Minimum execution time: 28_027_000 picoseconds. - Weight::from_parts(29_047_000, 3593) + // Minimum execution time: 27_627_000 picoseconds. + Weight::from_parts(28_344_000, 3593) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -174,8 +174,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `103` // Estimated: `3593` - // Minimum execution time: 11_796_000 picoseconds. - Weight::from_parts(12_239_000, 3593) + // Minimum execution time: 12_036_000 picoseconds. + Weight::from_parts(12_609_000, 3593) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } diff --git a/runtime/gear/src/weights/pallet_gear.rs b/runtime/gear/src/weights/pallet_gear.rs index 5f4f609d752..b86b0c49d63 100644 --- a/runtime/gear/src/weights/pallet_gear.rs +++ b/runtime/gear/src/weights/pallet_gear.rs @@ -19,13 +19,13 @@ //! Autogenerated weights for pallet_gear //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-09-21, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-09-28, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` //! CPU: `Intel(R) Xeon(R) Platinum 8375C CPU @ 2.90GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("gear-dev"), DB CACHE: 1024 // Executed Command: -// ./target/production/gear benchmark pallet --chain=gear-dev --steps=50 --repeat=20 --pallet=pallet_gear --extrinsic=* --execution=wasm --wasm-execution=compiled --heap-pages=4096 --output=./scripts/benchmarking/weights-output/pallet_gear.rs --template=.maintain/frame-weight-template.hbs +// ./target/production/gear benchmark pallet --chain=gear-dev --steps=50 --repeat=20 --pallet=pallet_gear --extrinsic=alloc,alloc_in_handle,alloc_per_page,claim_value,create_program,db_read_per_kb,db_write_per_kb,free,gr_block_height,gr_block_timestamp,gr_create_program,gr_create_program_per_kb,gr_create_program_wgas,gr_create_program_wgas_per_kb,gr_debug,gr_debug_per_kb,gr_gas_available,gr_message_id,gr_pay_program_rent,gr_program_id,gr_random,gr_read,gr_read_per_kb,gr_reply_code,gr_reply_deposit,gr_reply_per_kb,gr_reply_push,gr_reply_push_input,gr_reply_push_input_per_kb,gr_reply_push_per_kb,gr_reply_to,gr_reply_wgas_per_kb,gr_reservation_reply_commit_per_kb,gr_reservation_reply_per_kb,gr_reservation_send,gr_reservation_send_commit,gr_reservation_send_per_kb,gr_reserve_gas,gr_send,gr_send_commit,gr_send_commit_wgas,gr_send_init,gr_send_input,gr_send_input_wgas,gr_send_per_kb,gr_send_push,gr_send_push_input,gr_send_push_input_per_kb,gr_send_push_per_kb,gr_send_wgas,gr_send_wgas_per_kb,gr_signal_code,gr_signal_from,gr_size,gr_source,gr_system_reserve_gas,gr_unreserve_gas,gr_value,gr_value_available,gr_wake,initial_allocation,instantiate_module_per_kb,instr_br,instr_br_if,instr_br_table,instr_br_table_per_entry,instr_call,instr_call_const,instr_call_indirect,instr_call_indirect_per_param,instr_call_per_local,instr_global_get,instr_global_set,instr_i32add,instr_i32and,instr_i32clz,instr_i32ctz,instr_i32divs,instr_i32divu,instr_i32eq,instr_i32eqz,instr_i32extend16s,instr_i32extend8s,instr_i32ges,instr_i32geu,instr_i32gts,instr_i32gtu,instr_i32les,instr_i32leu,instr_i32load,instr_i32lts,instr_i32ltu,instr_i32mul,instr_i32ne,instr_i32or,instr_i32popcnt,instr_i32rems,instr_i32remu,instr_i32rotl,instr_i32rotr,instr_i32shl,instr_i32shrs,instr_i32shru,instr_i32store,instr_i32sub,instr_i32wrapi64,instr_i32xor,instr_i64add,instr_i64and,instr_i64clz,instr_i64ctz,instr_i64divs,instr_i64divu,instr_i64eq,instr_i64eqz,instr_i64extend16s,instr_i64extend32s,instr_i64extend8s,instr_i64extendsi32,instr_i64extendui32,instr_i64ges,instr_i64geu,instr_i64gts,instr_i64gtu,instr_i64les,instr_i64leu,instr_i64load,instr_i64lts,instr_i64ltu,instr_i64mul,instr_i64ne,instr_i64or,instr_i64popcnt,instr_i64rems,instr_i64remu,instr_i64rotl,instr_i64rotr,instr_i64shl,instr_i64shrs,instr_i64shru,instr_i64store,instr_i64sub,instr_i64xor,instr_if,instr_local_get,instr_local_set,instr_local_tee,instr_memory_current,instr_select,lazy_pages_host_func_read,lazy_pages_host_func_write,lazy_pages_host_func_write_after_read,lazy_pages_load_page_storage_data,lazy_pages_signal_read,lazy_pages_signal_write,lazy_pages_signal_write_after_read,mem_grow,pay_program_rent,reinstrument_per_kb,resume_session_commit,resume_session_init,resume_session_push,send_message,send_reply,tasks_pause_program,tasks_pause_program_uninited,tasks_remove_from_mailbox,tasks_remove_from_waitlist,tasks_remove_gas_reservation,tasks_remove_resume_session,tasks_send_dispatch,tasks_send_user_message,tasks_send_user_message_to_mailbox,tasks_wake_message,tasks_wake_message_no_wake,upload_code,upload_program --execution=wasm --wasm-execution=compiled --heap-pages=4096 --output=./scripts/benchmarking/weights-output/pallet_gear.rs --template=.maintain/frame-weight-template.hbs #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(unused_parens)] @@ -37,6 +37,19 @@ use sp_std::marker::PhantomData; /// Weight functions needed for pallet_gear. pub trait WeightInfo { + fn gr_reply(r: u32, ) -> Weight; + fn gr_reply_wgas(r: u32, ) -> Weight; + fn gr_reply_commit(r: u32, ) -> Weight; + fn gr_reply_commit_wgas(r: u32, ) -> Weight; + fn gr_reply_input(r: u32, ) -> Weight; + fn gr_reply_input_wgas(r: u32, ) -> Weight; + fn gr_reservation_reply(r: u32, ) -> Weight; + fn gr_reservation_reply_commit(r: u32, ) -> Weight; + fn gr_exit(r: u32, ) -> Weight; + fn gr_leave(r: u32, ) -> Weight; + fn gr_wait(r: u32, ) -> Weight; + fn gr_wait_for(r: u32, ) -> Weight; + fn gr_wait_up_to(r: u32, ) -> Weight; fn db_write_per_kb(c: u32, ) -> Weight; fn db_read_per_kb(c: u32, ) -> Weight; fn instantiate_module_per_kb(c: u32, ) -> Weight; @@ -86,19 +99,11 @@ pub trait WeightInfo { fn gr_reservation_send(r: u32, ) -> Weight; fn gr_reservation_send_per_kb(n: u32, ) -> Weight; fn gr_reservation_send_commit(r: u32, ) -> Weight; - fn gr_reply(r: u32, ) -> Weight; fn gr_reply_per_kb(n: u32, ) -> Weight; - fn gr_reply_wgas(r: u32, ) -> Weight; fn gr_reply_wgas_per_kb(n: u32, ) -> Weight; - fn gr_reply_commit(r: u32, ) -> Weight; - fn gr_reply_commit_wgas(r: u32, ) -> Weight; fn gr_reply_push(r: u32, ) -> Weight; fn gr_reply_push_per_kb(n: u32, ) -> Weight; - fn gr_reply_input(r: u32, ) -> Weight; - fn gr_reply_input_wgas(r: u32, ) -> Weight; - fn gr_reservation_reply(r: u32, ) -> Weight; fn gr_reservation_reply_per_kb(n: u32, ) -> Weight; - fn gr_reservation_reply_commit(r: u32, ) -> Weight; fn gr_reservation_reply_commit_per_kb(n: u32, ) -> Weight; fn gr_reply_to(r: u32, ) -> Weight; fn gr_signal_code(r: u32, ) -> Weight; @@ -110,11 +115,6 @@ pub trait WeightInfo { fn gr_debug(r: u32, ) -> Weight; fn gr_debug_per_kb(n: u32, ) -> Weight; fn gr_reply_code(r: u32, ) -> Weight; - fn gr_exit(r: u32, ) -> Weight; - fn gr_leave(r: u32, ) -> Weight; - fn gr_wait(r: u32, ) -> Weight; - fn gr_wait_for(r: u32, ) -> Weight; - fn gr_wait_up_to(r: u32, ) -> Weight; fn gr_wake(r: u32, ) -> Weight; fn gr_create_program(r: u32, ) -> Weight; fn gr_create_program_per_kb(p: u32, s: u32, ) -> Weight; @@ -237,6 +237,136 @@ pub trait WeightInfo { /// Weights for pallet_gear using the Gear node and recommended hardware. pub struct SubstrateWeight(PhantomData); impl pallet_gear::WeightInfo for SubstrateWeight { + /// The range of component `r` is `[0, 1]`. + fn gr_reply(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 94_792_000 picoseconds. + Weight::from_parts(103_063_604, 0) + // Standard Error: 103_375 + .saturating_add(Weight::from_parts(18_929_072, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_reply_wgas(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 96_154_000 picoseconds. + Weight::from_parts(107_249_232, 0) + // Standard Error: 99_969 + .saturating_add(Weight::from_parts(19_062_846, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_reply_commit(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 98_701_000 picoseconds. + Weight::from_parts(109_478_842, 0) + // Standard Error: 104_175 + .saturating_add(Weight::from_parts(10_887_124, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_reply_commit_wgas(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 102_910_000 picoseconds. + Weight::from_parts(109_181_566, 0) + // Standard Error: 81_801 + .saturating_add(Weight::from_parts(12_077_508, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_reply_input(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 719_481_000 picoseconds. + Weight::from_parts(765_485_196, 0) + // Standard Error: 676_170 + .saturating_add(Weight::from_parts(17_778_524, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_reply_input_wgas(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 720_914_000 picoseconds. + Weight::from_parts(776_554_516, 0) + // Standard Error: 1_018_495 + .saturating_add(Weight::from_parts(38_306_948, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_reservation_reply(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 105_823_000 picoseconds. + Weight::from_parts(112_820_586, 0) + // Standard Error: 82_530 + .saturating_add(Weight::from_parts(14_370_506, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_reservation_reply_commit(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 102_415_000 picoseconds. + Weight::from_parts(110_005_402, 0) + // Standard Error: 87_514 + .saturating_add(Weight::from_parts(6_578_880, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_exit(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 96_593_000 picoseconds. + Weight::from_parts(104_873_732, 0) + // Standard Error: 2_095_391 + .saturating_add(Weight::from_parts(193_359_282, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_leave(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 93_619_000 picoseconds. + Weight::from_parts(99_623_244, 0) + // Standard Error: 1_945_328 + .saturating_add(Weight::from_parts(179_784_494, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_wait(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 92_936_000 picoseconds. + Weight::from_parts(100_139_452, 0) + // Standard Error: 1_753_555 + .saturating_add(Weight::from_parts(132_465_876, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_wait_for(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 93_955_000 picoseconds. + Weight::from_parts(100_650_632, 0) + // Standard Error: 2_018_388 + .saturating_add(Weight::from_parts(178_916_382, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_wait_up_to(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 95_467_000 picoseconds. + Weight::from_parts(102_532_790, 0) + // Standard Error: 2_065_180 + .saturating_add(Weight::from_parts(187_152_790, 0).saturating_mul(r.into())) + } fn allocation_cost() -> Weight { // To be changed with the proper value. T::DbWeight::get().writes(1) @@ -256,21 +386,21 @@ impl pallet_gear::WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_023_000 picoseconds. - Weight::from_parts(1_051_000, 0) - // Standard Error: 912 - .saturating_add(Weight::from_parts(213_761, 0).saturating_mul(c.into())) + // Minimum execution time: 1_040_000 picoseconds. + Weight::from_parts(1_087_000, 0) + // Standard Error: 940 + .saturating_add(Weight::from_parts(251_751, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().writes(1_u64)) } /// The range of component `c` is `[0, 512]`. fn db_read_per_kb(c: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `146 + c * (1024 ±0)` - // Estimated: `3610 + c * (1024 ±0)` - // Minimum execution time: 3_252_000 picoseconds. - Weight::from_parts(3_416_000, 3610) - // Standard Error: 1_261 - .saturating_add(Weight::from_parts(689_572, 0).saturating_mul(c.into())) + // Measured: `79 + c * (1024 ±0)` + // Estimated: `3543 + c * (1024 ±0)` + // Minimum execution time: 3_333_000 picoseconds. + Weight::from_parts(3_463_000, 3543) + // Standard Error: 966 + .saturating_add(Weight::from_parts(678_430, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(Weight::from_parts(0, 1024).saturating_mul(c.into())) } @@ -279,35 +409,35 @@ impl pallet_gear::WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 59_805_000 picoseconds. - Weight::from_parts(86_729_126, 0) - // Standard Error: 7_023 - .saturating_add(Weight::from_parts(2_475_519, 0).saturating_mul(c.into())) + // Minimum execution time: 61_586_000 picoseconds. + Weight::from_parts(95_956_778, 0) + // Standard Error: 5_472 + .saturating_add(Weight::from_parts(2_353_352, 0).saturating_mul(c.into())) } fn claim_value() -> Weight { // Proof Size summary in bytes: - // Measured: `1372` - // Estimated: `51905` - // Minimum execution time: 107_694_000 picoseconds. - Weight::from_parts(110_328_000, 51905) + // Measured: `1304` + // Estimated: `51293` + // Minimum execution time: 105_420_000 picoseconds. + Weight::from_parts(109_120_000, 51293) .saturating_add(T::DbWeight::get().reads(15_u64)) .saturating_add(T::DbWeight::get().writes(12_u64)) } fn pay_program_rent() -> Weight { // Proof Size summary in bytes: - // Measured: `992` - // Estimated: `21579` - // Minimum execution time: 55_980_000 picoseconds. - Weight::from_parts(56_766_000, 21579) + // Measured: `923` + // Estimated: `21372` + // Minimum execution time: 54_290_000 picoseconds. + Weight::from_parts(55_929_000, 21372) .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().writes(6_u64)) } fn resume_session_init() -> Weight { // Proof Size summary in bytes: - // Measured: `638` - // Estimated: `17486` - // Minimum execution time: 29_973_000 picoseconds. - Weight::from_parts(31_008_000, 17486) + // Measured: `570` + // Estimated: `17214` + // Minimum execution time: 29_539_000 picoseconds. + Weight::from_parts(30_515_000, 17214) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().writes(4_u64)) } @@ -316,22 +446,22 @@ impl pallet_gear::WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `355` // Estimated: `7640` - // Minimum execution time: 8_054_000 picoseconds. - Weight::from_parts(8_342_000, 7640) - // Standard Error: 17_771 - .saturating_add(Weight::from_parts(13_335_661, 0).saturating_mul(c.into())) + // Minimum execution time: 8_426_000 picoseconds. + Weight::from_parts(5_984_423, 7640) + // Standard Error: 33_789 + .saturating_add(Weight::from_parts(13_895_151, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) } /// The range of component `c` is `[0, 2044]`. fn resume_session_commit(c: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `1593 + c * (16389 ±0)` - // Estimated: `43266 + c * (131112 ±0)` - // Minimum execution time: 72_178_000 picoseconds. - Weight::from_parts(73_341_000, 43266) - // Standard Error: 167_723 - .saturating_add(Weight::from_parts(54_442_045, 0).saturating_mul(c.into())) + // Measured: `1457 + c * (16389 ±0)` + // Estimated: `42178 + c * (131112 ±0)` + // Minimum execution time: 71_198_000 picoseconds. + Weight::from_parts(72_033_000, 42178) + // Standard Error: 159_543 + .saturating_add(Weight::from_parts(54_764_270, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(11_u64)) .saturating_add(T::DbWeight::get().writes(9_u64)) .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(c.into()))) @@ -340,24 +470,24 @@ impl pallet_gear::WeightInfo for SubstrateWeight { /// The range of component `c` is `[0, 250]`. fn upload_code(c: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `113` - // Estimated: `5402` - // Minimum execution time: 78_662_000 picoseconds. - Weight::from_parts(42_066_175, 5402) - // Standard Error: 52_075 - .saturating_add(Weight::from_parts(60_249_549, 0).saturating_mul(c.into())) + // Measured: `46` + // Estimated: `5134` + // Minimum execution time: 77_259_000 picoseconds. + Weight::from_parts(52_968_469, 5134) + // Standard Error: 43_186 + .saturating_add(Weight::from_parts(59_988_588, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(4_u64)) } /// The range of component `s` is `[0, 4194304]`. fn create_program(s: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `1111` - // Estimated: `50600` - // Minimum execution time: 94_321_000 picoseconds. - Weight::from_parts(129_113_540, 50600) - // Standard Error: 1 - .saturating_add(Weight::from_parts(2_625, 0).saturating_mul(s.into())) + // Measured: `1043` + // Estimated: `49852` + // Minimum execution time: 96_734_000 picoseconds. + Weight::from_parts(136_364_170, 49852) + // Standard Error: 0 + .saturating_add(Weight::from_parts(2_592, 0).saturating_mul(s.into())) .saturating_add(T::DbWeight::get().reads(15_u64)) .saturating_add(T::DbWeight::get().writes(12_u64)) } @@ -365,72 +495,72 @@ impl pallet_gear::WeightInfo for SubstrateWeight { /// The range of component `s` is `[0, 4194304]`. fn upload_program(c: u32, s: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `521` - // Estimated: `45152` - // Minimum execution time: 11_148_491_000 picoseconds. - Weight::from_parts(21_065_971, 45152) - // Standard Error: 173_883 - .saturating_add(Weight::from_parts(60_839_567, 0).saturating_mul(c.into())) - // Standard Error: 10 - .saturating_add(Weight::from_parts(2_652, 0).saturating_mul(s.into())) + // Measured: `453` + // Estimated: `44268` + // Minimum execution time: 11_047_048_000 picoseconds. + Weight::from_parts(211_012_859, 44268) + // Standard Error: 157_221 + .saturating_add(Weight::from_parts(59_860_835, 0).saturating_mul(c.into())) + // Standard Error: 9 + .saturating_add(Weight::from_parts(2_554, 0).saturating_mul(s.into())) .saturating_add(T::DbWeight::get().reads(15_u64)) .saturating_add(T::DbWeight::get().writes(16_u64)) } /// The range of component `p` is `[0, 2097152]`. fn send_message(p: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `531` - // Estimated: `31266` - // Minimum execution time: 73_302_000 picoseconds. - Weight::from_parts(47_279_667, 31266) + // Measured: `530` + // Estimated: `31259` + // Minimum execution time: 73_682_000 picoseconds. + Weight::from_parts(48_414_295, 31259) // Standard Error: 1 - .saturating_add(Weight::from_parts(1_055, 0).saturating_mul(p.into())) + .saturating_add(Weight::from_parts(1_040, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads(11_u64)) .saturating_add(T::DbWeight::get().writes(10_u64)) } /// The range of component `p` is `[0, 2097152]`. fn send_reply(p: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `1371` - // Estimated: `54435` - // Minimum execution time: 124_173_000 picoseconds. - Weight::from_parts(96_458_887, 54435) - // Standard Error: 2 - .saturating_add(Weight::from_parts(1_078, 0).saturating_mul(p.into())) + // Measured: `1303` + // Estimated: `53823` + // Minimum execution time: 122_837_000 picoseconds. + Weight::from_parts(97_209_014, 53823) + // Standard Error: 1 + .saturating_add(Weight::from_parts(1_068, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads(16_u64)) .saturating_add(T::DbWeight::get().writes(13_u64)) } /// The range of component `q` is `[1, 512]`. fn initial_allocation(_q: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `1893` - // Estimated: `114612` - // Minimum execution time: 365_983_000 picoseconds. - Weight::from_parts(387_416_952, 114612) - .saturating_add(T::DbWeight::get().reads(33_u64)) - .saturating_add(T::DbWeight::get().writes(26_u64)) + // Measured: `979` + // Estimated: `89393` + // Minimum execution time: 354_207_000 picoseconds. + Weight::from_parts(374_297_966, 89393) + .saturating_add(T::DbWeight::get().reads(31_u64)) + .saturating_add(T::DbWeight::get().writes(24_u64)) } /// The range of component `q` is `[0, 512]`. fn alloc_in_handle(q: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `1893` - // Estimated: `114612` - // Minimum execution time: 380_430_000 picoseconds. - Weight::from_parts(403_376_118, 114612) - // Standard Error: 2_451 - .saturating_add(Weight::from_parts(1_137, 0).saturating_mul(q.into())) - .saturating_add(T::DbWeight::get().reads(33_u64)) - .saturating_add(T::DbWeight::get().writes(26_u64)) + // Measured: `979` + // Estimated: `89133` + // Minimum execution time: 368_424_000 picoseconds. + Weight::from_parts(387_073_481, 89133) + // Standard Error: 1_472 + .saturating_add(Weight::from_parts(4_343, 0).saturating_mul(q.into())) + .saturating_add(T::DbWeight::get().reads(31_u64)) + .saturating_add(T::DbWeight::get().writes(24_u64)) } /// The range of component `c` is `[0, 512]`. fn reinstrument_per_kb(c: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `211 + c * (1075 ±0)` // Estimated: `3899 + c * (2150 ±0)` - // Minimum execution time: 58_080_000 picoseconds. - Weight::from_parts(58_601_000, 3899) - // Standard Error: 36_083 - .saturating_add(Weight::from_parts(58_395_643, 0).saturating_mul(c.into())) + // Minimum execution time: 58_209_000 picoseconds. + Weight::from_parts(58_498_000, 3899) + // Standard Error: 35_860 + .saturating_add(Weight::from_parts(58_109_594, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) .saturating_add(Weight::from_parts(0, 2150).saturating_mul(c.into())) @@ -440,638 +570,510 @@ impl pallet_gear::WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 91_412_000 picoseconds. - Weight::from_parts(94_168_000, 0) - // Standard Error: 3_806_298 - .saturating_add(Weight::from_parts(673_774_453, 0).saturating_mul(r.into())) + // Minimum execution time: 92_645_000 picoseconds. + Weight::from_parts(95_763_000, 0) + // Standard Error: 3_691_564 + .saturating_add(Weight::from_parts(713_537_659, 0).saturating_mul(r.into())) } /// The range of component `p` is `[1, 512]`. fn alloc_per_page(p: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 452_549_000 picoseconds. - Weight::from_parts(398_963_700, 0) - // Standard Error: 7_042 - .saturating_add(Weight::from_parts(29_406_609, 0).saturating_mul(p.into())) + // Minimum execution time: 495_006_000 picoseconds. + Weight::from_parts(421_459_793, 0) + // Standard Error: 9_156 + .saturating_add(Weight::from_parts(29_070_022, 0).saturating_mul(p.into())) } /// The range of component `r` is `[0, 20]`. fn free(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 207_052_000 picoseconds. - Weight::from_parts(209_606_478, 0) - // Standard Error: 255_281 - .saturating_add(Weight::from_parts(62_959_531, 0).saturating_mul(r.into())) + // Minimum execution time: 219_414_000 picoseconds. + Weight::from_parts(206_118_379, 0) + // Standard Error: 320_555 + .saturating_add(Weight::from_parts(64_665_141, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 256]`. fn gr_reserve_gas(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 97_729_000 picoseconds. - Weight::from_parts(105_964_750, 0) - // Standard Error: 4_847 - .saturating_add(Weight::from_parts(2_433_966, 0).saturating_mul(r.into())) + // Minimum execution time: 96_871_000 picoseconds. + Weight::from_parts(104_318_392, 0) + // Standard Error: 4_224 + .saturating_add(Weight::from_parts(2_443_618, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 256]`. fn gr_unreserve_gas(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 175_010_000 picoseconds. - Weight::from_parts(229_153_209, 0) - // Standard Error: 17_116 - .saturating_add(Weight::from_parts(1_991_260, 0).saturating_mul(r.into())) + // Minimum execution time: 152_658_000 picoseconds. + Weight::from_parts(218_177_774, 0) + // Standard Error: 23_640 + .saturating_add(Weight::from_parts(2_186_094, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_system_reserve_gas(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 94_696_000 picoseconds. - Weight::from_parts(119_674_535, 0) - // Standard Error: 387_178 - .saturating_add(Weight::from_parts(98_102_856, 0).saturating_mul(r.into())) + // Minimum execution time: 97_532_000 picoseconds. + Weight::from_parts(112_244_990, 0) + // Standard Error: 370_435 + .saturating_add(Weight::from_parts(102_977_688, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_message_id(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 95_794_000 picoseconds. - Weight::from_parts(89_931_979, 0) - // Standard Error: 371_349 - .saturating_add(Weight::from_parts(86_524_059, 0).saturating_mul(r.into())) + // Minimum execution time: 95_116_000 picoseconds. + Weight::from_parts(85_754_801, 0) + // Standard Error: 322_936 + .saturating_add(Weight::from_parts(85_646_040, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_program_id(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 97_924_000 picoseconds. - Weight::from_parts(84_041_201, 0) - // Standard Error: 327_841 - .saturating_add(Weight::from_parts(95_483_315, 0).saturating_mul(r.into())) + // Minimum execution time: 97_226_000 picoseconds. + Weight::from_parts(96_400_189, 0) + // Standard Error: 308_975 + .saturating_add(Weight::from_parts(84_400_658, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_source(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 97_122_000 picoseconds. - Weight::from_parts(86_789_268, 0) - // Standard Error: 353_259 - .saturating_add(Weight::from_parts(85_698_317, 0).saturating_mul(r.into())) + // Minimum execution time: 96_667_000 picoseconds. + Weight::from_parts(95_221_535, 0) + // Standard Error: 320_528 + .saturating_add(Weight::from_parts(85_320_330, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_value(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 94_821_000 picoseconds. - Weight::from_parts(92_694_130, 0) - // Standard Error: 340_146 - .saturating_add(Weight::from_parts(84_623_945, 0).saturating_mul(r.into())) + // Minimum execution time: 96_400_000 picoseconds. + Weight::from_parts(83_830_464, 0) + // Standard Error: 333_677 + .saturating_add(Weight::from_parts(86_153_462, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_value_available(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 93_840_000 picoseconds. - Weight::from_parts(87_888_572, 0) - // Standard Error: 369_465 - .saturating_add(Weight::from_parts(85_638_902, 0).saturating_mul(r.into())) + // Minimum execution time: 98_322_000 picoseconds. + Weight::from_parts(88_780_011, 0) + // Standard Error: 365_736 + .saturating_add(Weight::from_parts(86_373_607, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_gas_available(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 98_597_000 picoseconds. - Weight::from_parts(86_642_386, 0) - // Standard Error: 362_257 - .saturating_add(Weight::from_parts(85_598_887, 0).saturating_mul(r.into())) + // Minimum execution time: 94_234_000 picoseconds. + Weight::from_parts(93_394_916, 0) + // Standard Error: 310_495 + .saturating_add(Weight::from_parts(85_678_300, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_size(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 94_546_000 picoseconds. - Weight::from_parts(91_466_289, 0) - // Standard Error: 344_423 - .saturating_add(Weight::from_parts(84_318_848, 0).saturating_mul(r.into())) + // Minimum execution time: 95_316_000 picoseconds. + Weight::from_parts(88_012_950, 0) + // Standard Error: 309_598 + .saturating_add(Weight::from_parts(85_813_369, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_read(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 578_036_000 picoseconds. - Weight::from_parts(696_140_951, 0) - // Standard Error: 559_498 - .saturating_add(Weight::from_parts(149_397_501, 0).saturating_mul(r.into())) + // Minimum execution time: 715_150_000 picoseconds. + Weight::from_parts(769_593_524, 0) + // Standard Error: 493_525 + .saturating_add(Weight::from_parts(140_935_499, 0).saturating_mul(r.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_read_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 723_788_000 picoseconds. - Weight::from_parts(740_225_000, 0) - // Standard Error: 52_895 - .saturating_add(Weight::from_parts(13_188_120, 0).saturating_mul(n.into())) + // Minimum execution time: 844_162_000 picoseconds. + Weight::from_parts(851_053_000, 0) + // Standard Error: 50_294 + .saturating_add(Weight::from_parts(13_068_816, 0).saturating_mul(n.into())) } /// The range of component `r` is `[0, 20]`. fn gr_block_height(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 99_012_000 picoseconds. - Weight::from_parts(88_269_135, 0) - // Standard Error: 296_136 - .saturating_add(Weight::from_parts(92_296_104, 0).saturating_mul(r.into())) + // Minimum execution time: 94_243_000 picoseconds. + Weight::from_parts(87_583_955, 0) + // Standard Error: 343_578 + .saturating_add(Weight::from_parts(84_267_053, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_block_timestamp(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 93_803_000 picoseconds. - Weight::from_parts(87_097_769, 0) - // Standard Error: 367_325 - .saturating_add(Weight::from_parts(84_987_043, 0).saturating_mul(r.into())) + // Minimum execution time: 95_559_000 picoseconds. + Weight::from_parts(92_460_596, 0) + // Standard Error: 340_344 + .saturating_add(Weight::from_parts(85_006_110, 0).saturating_mul(r.into())) } /// The range of component `n` is `[0, 20]`. fn gr_random(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 96_663_000 picoseconds. - Weight::from_parts(105_357_427, 0) - // Standard Error: 366_135 - .saturating_add(Weight::from_parts(172_109_201, 0).saturating_mul(n.into())) + // Minimum execution time: 95_023_000 picoseconds. + Weight::from_parts(113_045_564, 0) + // Standard Error: 350_542 + .saturating_add(Weight::from_parts(169_289_972, 0).saturating_mul(n.into())) } /// The range of component `r` is `[0, 20]`. fn gr_reply_deposit(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 99_210_000 picoseconds. - Weight::from_parts(102_217_000, 0) - // Standard Error: 4_527_119 - .saturating_add(Weight::from_parts(845_784_967, 0).saturating_mul(r.into())) + // Minimum execution time: 95_407_000 picoseconds. + Weight::from_parts(99_094_000, 0) + // Standard Error: 3_585_438 + .saturating_add(Weight::from_parts(776_362_449, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_send(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 96_579_000 picoseconds. - Weight::from_parts(162_452_429, 0) - // Standard Error: 416_836 - .saturating_add(Weight::from_parts(257_900_517, 0).saturating_mul(r.into())) + // Minimum execution time: 96_709_000 picoseconds. + Weight::from_parts(153_262_764, 0) + // Standard Error: 391_637 + .saturating_add(Weight::from_parts(256_389_022, 0).saturating_mul(r.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_send_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 353_526_000 picoseconds. - Weight::from_parts(358_025_000, 0) - // Standard Error: 61_984 - .saturating_add(Weight::from_parts(21_521_461, 0).saturating_mul(n.into())) + // Minimum execution time: 341_633_000 picoseconds. + Weight::from_parts(345_693_000, 0) + // Standard Error: 61_029 + .saturating_add(Weight::from_parts(21_298_548, 0).saturating_mul(n.into())) } /// The range of component `r` is `[0, 20]`. fn gr_send_wgas(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 94_822_000 picoseconds. - Weight::from_parts(168_431_611, 0) - // Standard Error: 378_696 - .saturating_add(Weight::from_parts(263_135_958, 0).saturating_mul(r.into())) + // Minimum execution time: 97_817_000 picoseconds. + Weight::from_parts(172_033_153, 0) + // Standard Error: 412_230 + .saturating_add(Weight::from_parts(260_826_119, 0).saturating_mul(r.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_send_wgas_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 351_828_000 picoseconds. - Weight::from_parts(355_382_000, 0) - // Standard Error: 60_589 - .saturating_add(Weight::from_parts(21_325_400, 0).saturating_mul(n.into())) + // Minimum execution time: 353_433_000 picoseconds. + Weight::from_parts(359_185_000, 0) + // Standard Error: 60_153 + .saturating_add(Weight::from_parts(21_224_949, 0).saturating_mul(n.into())) } /// The range of component `r` is `[0, 20]`. fn gr_send_input(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 569_384_000 picoseconds. - Weight::from_parts(638_474_730, 0) - // Standard Error: 425_903 - .saturating_add(Weight::from_parts(275_691_711, 0).saturating_mul(r.into())) + // Minimum execution time: 716_180_000 picoseconds. + Weight::from_parts(782_890_839, 0) + // Standard Error: 547_225 + .saturating_add(Weight::from_parts(273_570_636, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_send_input_wgas(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 573_053_000 picoseconds. - Weight::from_parts(640_078_802, 0) - // Standard Error: 475_389 - .saturating_add(Weight::from_parts(284_337_155, 0).saturating_mul(r.into())) + // Minimum execution time: 719_827_000 picoseconds. + Weight::from_parts(805_763_844, 0) + // Standard Error: 503_245 + .saturating_add(Weight::from_parts(278_200_889, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_send_init(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 98_223_000 picoseconds. - Weight::from_parts(85_732_985, 0) - // Standard Error: 336_308 - .saturating_add(Weight::from_parts(92_936_006, 0).saturating_mul(r.into())) + // Minimum execution time: 96_518_000 picoseconds. + Weight::from_parts(82_218_173, 0) + // Standard Error: 358_867 + .saturating_add(Weight::from_parts(92_408_337, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_send_push(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_822_621_000 picoseconds. - Weight::from_parts(1_951_955_018, 0) - // Standard Error: 339_415 - .saturating_add(Weight::from_parts(157_557_756, 0).saturating_mul(r.into())) + // Minimum execution time: 1_829_368_000 picoseconds. + Weight::from_parts(1_976_758_302, 0) + // Standard Error: 349_703 + .saturating_add(Weight::from_parts(163_038_781, 0).saturating_mul(r.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_send_push_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 314_296_000 picoseconds. - Weight::from_parts(317_522_000, 0) - // Standard Error: 61_360 - .saturating_add(Weight::from_parts(29_499_741, 0).saturating_mul(n.into())) + // Minimum execution time: 315_829_000 picoseconds. + Weight::from_parts(318_464_000, 0) + // Standard Error: 54_637 + .saturating_add(Weight::from_parts(31_280_567, 0).saturating_mul(n.into())) } /// The range of component `r` is `[0, 20]`. fn gr_send_commit(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_835_106_000 picoseconds. - Weight::from_parts(1_948_516_646, 0) - // Standard Error: 382_008 - .saturating_add(Weight::from_parts(214_812_508, 0).saturating_mul(r.into())) + // Minimum execution time: 1_818_937_000 picoseconds. + Weight::from_parts(1_941_969_566, 0) + // Standard Error: 412_244 + .saturating_add(Weight::from_parts(220_650_756, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_send_commit_wgas(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_827_496_000 picoseconds. - Weight::from_parts(1_949_190_773, 0) - // Standard Error: 340_175 - .saturating_add(Weight::from_parts(218_001_536, 0).saturating_mul(r.into())) + // Minimum execution time: 1_815_762_000 picoseconds. + Weight::from_parts(1_958_182_203, 0) + // Standard Error: 374_381 + .saturating_add(Weight::from_parts(229_106_637, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_reservation_send(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 264_306_000 picoseconds. - Weight::from_parts(363_536_651, 0) - // Standard Error: 467_914 - .saturating_add(Weight::from_parts(265_564_072, 0).saturating_mul(r.into())) + // Minimum execution time: 259_040_000 picoseconds. + Weight::from_parts(345_586_401, 0) + // Standard Error: 402_258 + .saturating_add(Weight::from_parts(274_866_021, 0).saturating_mul(r.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_reservation_send_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 523_150_000 picoseconds. - Weight::from_parts(535_842_000, 0) - // Standard Error: 65_412 - .saturating_add(Weight::from_parts(21_698_063, 0).saturating_mul(n.into())) + // Minimum execution time: 523_014_000 picoseconds. + Weight::from_parts(525_681_000, 0) + // Standard Error: 56_470 + .saturating_add(Weight::from_parts(21_443_571, 0).saturating_mul(n.into())) } /// The range of component `r` is `[0, 20]`. fn gr_reservation_send_commit(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_974_743_000 picoseconds. - Weight::from_parts(2_096_494_995, 0) - // Standard Error: 474_778 - .saturating_add(Weight::from_parts(232_524_299, 0).saturating_mul(r.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_reply(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 94_139_000 picoseconds. - Weight::from_parts(101_775_569, 0) - // Standard Error: 452_439 - .saturating_add(Weight::from_parts(16_839_430, 0).saturating_mul(r.into())) + // Minimum execution time: 1_967_181_000 picoseconds. + Weight::from_parts(2_076_078_781, 0) + // Standard Error: 455_370 + .saturating_add(Weight::from_parts(246_494_683, 0).saturating_mul(r.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_reply_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 112_050_000 picoseconds. - Weight::from_parts(102_205_366, 0) - // Standard Error: 1_008 - .saturating_add(Weight::from_parts(431_304, 0).saturating_mul(n.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_reply_wgas(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 93_528_000 picoseconds. - Weight::from_parts(99_748_422, 0) - // Standard Error: 396_992 - .saturating_add(Weight::from_parts(20_536_877, 0).saturating_mul(r.into())) + // Minimum execution time: 114_790_000 picoseconds. + Weight::from_parts(106_908_278, 0) + // Standard Error: 1_274 + .saturating_add(Weight::from_parts(430_785, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_reply_wgas_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 117_832_000 picoseconds. - Weight::from_parts(104_552_847, 0) - // Standard Error: 1_402 - .saturating_add(Weight::from_parts(432_018, 0).saturating_mul(n.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_reply_commit(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 93_325_000 picoseconds. - Weight::from_parts(101_074_097, 0) - // Standard Error: 454_790 - .saturating_add(Weight::from_parts(20_838_102, 0).saturating_mul(r.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_reply_commit_wgas(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 93_800_000 picoseconds. - Weight::from_parts(102_249_326, 0) - // Standard Error: 463_488 - .saturating_add(Weight::from_parts(15_991_473, 0).saturating_mul(r.into())) + // Minimum execution time: 115_541_000 picoseconds. + Weight::from_parts(101_956_035, 0) + // Standard Error: 3_603 + .saturating_add(Weight::from_parts(442_387, 0).saturating_mul(n.into())) } /// The range of component `r` is `[0, 20]`. fn gr_reply_push(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 93_153_000 picoseconds. - Weight::from_parts(121_452_989, 0) - // Standard Error: 390_540 - .saturating_add(Weight::from_parts(145_641_178, 0).saturating_mul(r.into())) + // Minimum execution time: 94_082_000 picoseconds. + Weight::from_parts(138_243_307, 0) + // Standard Error: 409_163 + .saturating_add(Weight::from_parts(154_758_505, 0).saturating_mul(r.into())) } /// The range of component `n` is `[0, 8192]`. fn gr_reply_push_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 115_529_000 picoseconds. - Weight::from_parts(120_413_000, 0) - // Standard Error: 3_105 - .saturating_add(Weight::from_parts(640_863, 0).saturating_mul(n.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_reply_input(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 566_859_000 picoseconds. - Weight::from_parts(631_111_316, 0) - // Standard Error: 7_012_228 - .saturating_add(Weight::from_parts(21_896_983, 0).saturating_mul(r.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_reply_input_wgas(_r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 565_382_000 picoseconds. - Weight::from_parts(613_048_008, 0) - } - /// The range of component `r` is `[0, 1]`. - fn gr_reservation_reply(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 104_401_000 picoseconds. - Weight::from_parts(112_651_320, 0) - // Standard Error: 438_590 - .saturating_add(Weight::from_parts(11_095_379, 0).saturating_mul(r.into())) + // Minimum execution time: 111_536_000 picoseconds. + Weight::from_parts(114_497_000, 0) + // Standard Error: 2_599 + .saturating_add(Weight::from_parts(656_994, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_reservation_reply_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 115_615_000 picoseconds. - Weight::from_parts(112_987_750, 0) - // Standard Error: 960 - .saturating_add(Weight::from_parts(423_774, 0).saturating_mul(n.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_reservation_reply_commit(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 105_056_000 picoseconds. - Weight::from_parts(113_735_922, 0) - // Standard Error: 466_586 - .saturating_add(Weight::from_parts(5_305_577, 0).saturating_mul(r.into())) + // Minimum execution time: 114_322_000 picoseconds. + Weight::from_parts(113_131_028, 0) + // Standard Error: 3_727 + .saturating_add(Weight::from_parts(436_168, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_reservation_reply_commit_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 113_897_000 picoseconds. - Weight::from_parts(112_616_408, 0) - // Standard Error: 1_722 - .saturating_add(Weight::from_parts(428_420, 0).saturating_mul(n.into())) + // Minimum execution time: 117_751_000 picoseconds. + Weight::from_parts(161_418_174, 0) + // Standard Error: 6_635 + .saturating_add(Weight::from_parts(405_229, 0).saturating_mul(n.into())) } /// The range of component `r` is `[0, 20]`. fn gr_reply_to(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 93_845_000 picoseconds. - Weight::from_parts(97_247_314, 0) - // Standard Error: 366_814 - .saturating_add(Weight::from_parts(85_900_587, 0).saturating_mul(r.into())) + // Minimum execution time: 93_524_000 picoseconds. + Weight::from_parts(89_332_032, 0) + // Standard Error: 294_566 + .saturating_add(Weight::from_parts(86_798_759, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_signal_code(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 98_960_000 picoseconds. - Weight::from_parts(96_741_705, 0) - // Standard Error: 331_442 - .saturating_add(Weight::from_parts(82_371_743, 0).saturating_mul(r.into())) + // Minimum execution time: 95_216_000 picoseconds. + Weight::from_parts(83_424_786, 0) + // Standard Error: 316_301 + .saturating_add(Weight::from_parts(84_774_296, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_signal_from(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 95_150_000 picoseconds. - Weight::from_parts(94_807_000, 0) - // Standard Error: 308_494 - .saturating_add(Weight::from_parts(85_723_479, 0).saturating_mul(r.into())) + // Minimum execution time: 96_461_000 picoseconds. + Weight::from_parts(97_636_300, 0) + // Standard Error: 278_297 + .saturating_add(Weight::from_parts(86_743_159, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_reply_push_input(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 565_388_000 picoseconds. - Weight::from_parts(606_358_854, 0) - // Standard Error: 430_766 - .saturating_add(Weight::from_parts(108_769_267, 0).saturating_mul(r.into())) + // Minimum execution time: 724_902_000 picoseconds. + Weight::from_parts(784_128_285, 0) + // Standard Error: 444_406 + .saturating_add(Weight::from_parts(105_223_470, 0).saturating_mul(r.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_reply_push_input_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 591_660_000 picoseconds. - Weight::from_parts(597_035_528, 0) - // Standard Error: 2_641 - .saturating_add(Weight::from_parts(153_781, 0).saturating_mul(n.into())) + // Minimum execution time: 737_666_000 picoseconds. + Weight::from_parts(758_797_216, 0) + // Standard Error: 1_260 + .saturating_add(Weight::from_parts(154_837, 0).saturating_mul(n.into())) } /// The range of component `r` is `[0, 20]`. fn gr_send_push_input(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_317_147_000 picoseconds. - Weight::from_parts(2_514_940_964, 0) - // Standard Error: 546_319 - .saturating_add(Weight::from_parts(128_825_542, 0).saturating_mul(r.into())) + // Minimum execution time: 2_498_871_000 picoseconds. + Weight::from_parts(2_688_516_696, 0) + // Standard Error: 531_545 + .saturating_add(Weight::from_parts(131_060_314, 0).saturating_mul(r.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_send_push_input_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_560_344_000 picoseconds. - Weight::from_parts(2_512_409_449, 0) - // Standard Error: 15_466 - .saturating_add(Weight::from_parts(12_395_144, 0).saturating_mul(n.into())) + // Minimum execution time: 2_657_855_000 picoseconds. + Weight::from_parts(2_746_003_287, 0) + // Standard Error: 12_743 + .saturating_add(Weight::from_parts(13_716_214, 0).saturating_mul(n.into())) } /// The range of component `r` is `[0, 20]`. fn gr_debug(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 97_996_000 picoseconds. - Weight::from_parts(130_630_238, 0) - // Standard Error: 414_418 - .saturating_add(Weight::from_parts(114_735_577, 0).saturating_mul(r.into())) + // Minimum execution time: 96_990_000 picoseconds. + Weight::from_parts(110_812_744, 0) + // Standard Error: 347_035 + .saturating_add(Weight::from_parts(120_462_128, 0).saturating_mul(r.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_debug_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 157_513_000 picoseconds. - Weight::from_parts(160_584_000, 0) - // Standard Error: 57_227 - .saturating_add(Weight::from_parts(25_738_939, 0).saturating_mul(n.into())) + // Minimum execution time: 170_244_000 picoseconds. + Weight::from_parts(175_502_000, 0) + // Standard Error: 56_203 + .saturating_add(Weight::from_parts(25_870_902, 0).saturating_mul(n.into())) } /// The range of component `r` is `[0, 20]`. fn gr_reply_code(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 92_652_000 picoseconds. - Weight::from_parts(88_138_429, 0) - // Standard Error: 330_537 - .saturating_add(Weight::from_parts(83_235_234, 0).saturating_mul(r.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_exit(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 93_824_000 picoseconds. - Weight::from_parts(102_740_497, 0) - // Standard Error: 428_593 - .saturating_add(Weight::from_parts(23_682_102, 0).saturating_mul(r.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_leave(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 92_530_000 picoseconds. - Weight::from_parts(101_410_861, 0) - // Standard Error: 432_236 - .saturating_add(Weight::from_parts(12_196_938, 0).saturating_mul(r.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_wait(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 93_402_000 picoseconds. - Weight::from_parts(102_285_877, 0) - // Standard Error: 466_463 - .saturating_add(Weight::from_parts(13_156_522, 0).saturating_mul(r.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_wait_for(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 95_706_000 picoseconds. - Weight::from_parts(102_513_059, 0) - // Standard Error: 464_787 - .saturating_add(Weight::from_parts(13_986_540, 0).saturating_mul(r.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_wait_up_to(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 93_057_000 picoseconds. - Weight::from_parts(99_083_869, 0) - // Standard Error: 378_747 - .saturating_add(Weight::from_parts(12_230_330, 0).saturating_mul(r.into())) + // Minimum execution time: 97_676_000 picoseconds. + Weight::from_parts(91_226_383, 0) + // Standard Error: 320_296 + .saturating_add(Weight::from_parts(82_761_490, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_wake(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 177_947_000 picoseconds. - Weight::from_parts(226_692_243, 0) - // Standard Error: 265_725 - .saturating_add(Weight::from_parts(156_938_838, 0).saturating_mul(r.into())) + // Minimum execution time: 149_319_000 picoseconds. + Weight::from_parts(230_971_562, 0) + // Standard Error: 338_138 + .saturating_add(Weight::from_parts(157_262_608, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_create_program(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 107_346_000 picoseconds. - Weight::from_parts(160_631_540, 0) - // Standard Error: 352_753 - .saturating_add(Weight::from_parts(338_685_448, 0).saturating_mul(r.into())) + // Minimum execution time: 108_167_000 picoseconds. + Weight::from_parts(178_994_489, 0) + // Standard Error: 404_012 + .saturating_add(Weight::from_parts(348_487_075, 0).saturating_mul(r.into())) } /// The range of component `p` is `[0, 2048]`. /// The range of component `s` is `[1, 2048]`. @@ -1079,22 +1081,22 @@ impl pallet_gear::WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 44_754_074_000 picoseconds. - Weight::from_parts(44_833_050_000, 0) - // Standard Error: 269_308 - .saturating_add(Weight::from_parts(7_629_892, 0).saturating_mul(p.into())) - // Standard Error: 269_294 - .saturating_add(Weight::from_parts(179_148_245, 0).saturating_mul(s.into())) + // Minimum execution time: 43_645_119_000 picoseconds. + Weight::from_parts(43_811_648_000, 0) + // Standard Error: 262_276 + .saturating_add(Weight::from_parts(7_776_587, 0).saturating_mul(p.into())) + // Standard Error: 262_263 + .saturating_add(Weight::from_parts(178_958_075, 0).saturating_mul(s.into())) } /// The range of component `r` is `[0, 20]`. fn gr_create_program_wgas(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 108_278_000 picoseconds. - Weight::from_parts(161_208_126, 0) - // Standard Error: 368_644 - .saturating_add(Weight::from_parts(346_324_329, 0).saturating_mul(r.into())) + // Minimum execution time: 104_639_000 picoseconds. + Weight::from_parts(169_517_206, 0) + // Standard Error: 363_225 + .saturating_add(Weight::from_parts(357_078_703, 0).saturating_mul(r.into())) } /// The range of component `p` is `[0, 2048]`. /// The range of component `s` is `[1, 2048]`. @@ -1102,32 +1104,32 @@ impl pallet_gear::WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 44_266_209_000 picoseconds. - Weight::from_parts(44_559_345_000, 0) - // Standard Error: 270_420 - .saturating_add(Weight::from_parts(7_460_172, 0).saturating_mul(p.into())) - // Standard Error: 270_407 - .saturating_add(Weight::from_parts(179_211_260, 0).saturating_mul(s.into())) + // Minimum execution time: 46_491_851_000 picoseconds. + Weight::from_parts(46_603_783_000, 0) + // Standard Error: 280_431 + .saturating_add(Weight::from_parts(7_250_257, 0).saturating_mul(p.into())) + // Standard Error: 280_417 + .saturating_add(Weight::from_parts(177_722_888, 0).saturating_mul(s.into())) } /// The range of component `r` is `[0, 20]`. fn gr_pay_program_rent(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 94_889_000 picoseconds. - Weight::from_parts(115_310_524, 0) - // Standard Error: 34_049 - .saturating_add(Weight::from_parts(1_916_607, 0).saturating_mul(r.into())) + // Minimum execution time: 95_721_000 picoseconds. + Weight::from_parts(114_995_832, 0) + // Standard Error: 36_809 + .saturating_add(Weight::from_parts(1_873_016, 0).saturating_mul(r.into())) } /// The range of component `p` is `[0, 512]`. fn lazy_pages_signal_read(p: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `141` // Estimated: `1131 + p * (9900 ±0)` - // Minimum execution time: 97_825_000 picoseconds. - Weight::from_parts(251_440_245, 1131) - // Standard Error: 70_641 - .saturating_add(Weight::from_parts(15_652_952, 0).saturating_mul(p.into())) + // Minimum execution time: 97_655_000 picoseconds. + Weight::from_parts(138_058_498, 1131) + // Standard Error: 18_813 + .saturating_add(Weight::from_parts(16_311_194, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads((4_u64).saturating_mul(p.into()))) .saturating_add(Weight::from_parts(0, 9900).saturating_mul(p.into())) } @@ -1136,10 +1138,10 @@ impl pallet_gear::WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `141` // Estimated: `1131 + p * (9900 ±0)` - // Minimum execution time: 96_761_000 picoseconds. - Weight::from_parts(100_398_000, 1131) - // Standard Error: 45_532 - .saturating_add(Weight::from_parts(39_790_625, 0).saturating_mul(p.into())) + // Minimum execution time: 96_083_000 picoseconds. + Weight::from_parts(98_597_000, 1131) + // Standard Error: 43_515 + .saturating_add(Weight::from_parts(42_632_421, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads((4_u64).saturating_mul(p.into()))) .saturating_add(Weight::from_parts(0, 9900).saturating_mul(p.into())) } @@ -1148,10 +1150,10 @@ impl pallet_gear::WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `141` // Estimated: `5069931` - // Minimum execution time: 7_471_807_000 picoseconds. - Weight::from_parts(7_440_591_962, 5069931) - // Standard Error: 168_373 - .saturating_add(Weight::from_parts(40_244_359, 0).saturating_mul(p.into())) + // Minimum execution time: 8_196_422_000 picoseconds. + Weight::from_parts(8_474_214_520, 5069931) + // Standard Error: 71_564 + .saturating_add(Weight::from_parts(41_738_666, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads(2048_u64)) } /// The range of component `p` is `[0, 512]`. @@ -1159,10 +1161,10 @@ impl pallet_gear::WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `1813 + p * (65580 ±0)` // Estimated: `1939 + p * (75482 ±0)` - // Minimum execution time: 97_303_000 picoseconds. - Weight::from_parts(98_185_000, 1939) - // Standard Error: 38_471 - .saturating_add(Weight::from_parts(55_016_921, 0).saturating_mul(p.into())) + // Minimum execution time: 93_446_000 picoseconds. + Weight::from_parts(96_664_000, 1939) + // Standard Error: 46_722 + .saturating_add(Weight::from_parts(55_567_620, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads((4_u64).saturating_mul(p.into()))) .saturating_add(Weight::from_parts(0, 75482).saturating_mul(p.into())) } @@ -1171,10 +1173,10 @@ impl pallet_gear::WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `141` // Estimated: `1131 + p * (9900 ±0)` - // Minimum execution time: 102_497_000 picoseconds. - Weight::from_parts(104_932_685, 1131) - // Standard Error: 78_974 - .saturating_add(Weight::from_parts(39_257_150, 0).saturating_mul(p.into())) + // Minimum execution time: 106_137_000 picoseconds. + Weight::from_parts(107_751_954, 1131) + // Standard Error: 71_200 + .saturating_add(Weight::from_parts(41_236_505, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads((4_u64).saturating_mul(p.into()))) .saturating_add(Weight::from_parts(0, 9900).saturating_mul(p.into())) } @@ -1183,10 +1185,10 @@ impl pallet_gear::WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `141` // Estimated: `1496 + p * (9883 ±2)` - // Minimum execution time: 612_308_000 picoseconds. - Weight::from_parts(642_079_999, 1496) - // Standard Error: 357_245 - .saturating_add(Weight::from_parts(46_518_860, 0).saturating_mul(p.into())) + // Minimum execution time: 758_237_000 picoseconds. + Weight::from_parts(760_351_083, 1496) + // Standard Error: 319_479 + .saturating_add(Weight::from_parts(53_277_303, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads((4_u64).saturating_mul(p.into()))) .saturating_add(Weight::from_parts(0, 9883).saturating_mul(p.into())) } @@ -1195,10 +1197,10 @@ impl pallet_gear::WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `141` // Estimated: `317931` - // Minimum execution time: 1_068_248_000 picoseconds. - Weight::from_parts(1_080_741_205, 317931) - // Standard Error: 262_216 - .saturating_add(Weight::from_parts(50_047_907, 0).saturating_mul(p.into())) + // Minimum execution time: 1_299_071_000 picoseconds. + Weight::from_parts(1_320_542_278, 317931) + // Standard Error: 364_770 + .saturating_add(Weight::from_parts(53_225_083, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads(128_u64)) } /// The range of component `r` is `[0, 20]`. @@ -1206,303 +1208,303 @@ impl pallet_gear::WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 3_099_000 picoseconds. - Weight::from_parts(6_340_084, 0) - // Standard Error: 180_257 - .saturating_add(Weight::from_parts(74_666_091, 0).saturating_mul(r.into())) + // Minimum execution time: 4_118_000 picoseconds. + Weight::from_parts(7_418_987, 0) + // Standard Error: 299_976 + .saturating_add(Weight::from_parts(77_036_564, 0).saturating_mul(r.into())) } /// The range of component `r` is `[50, 500]`. fn instr_i64load(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 4_391_547_000 picoseconds. - Weight::from_parts(4_140_785_425, 0) - // Standard Error: 89_369 - .saturating_add(Weight::from_parts(5_769_622, 0).saturating_mul(r.into())) + // Minimum execution time: 4_461_228_000 picoseconds. + Weight::from_parts(4_172_544_233, 0) + // Standard Error: 108_717 + .saturating_add(Weight::from_parts(5_492_504, 0).saturating_mul(r.into())) } /// The range of component `r` is `[50, 500]`. fn instr_i32load(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 4_386_802_000 picoseconds. - Weight::from_parts(4_243_536_456, 0) - // Standard Error: 95_210 - .saturating_add(Weight::from_parts(5_278_131, 0).saturating_mul(r.into())) + // Minimum execution time: 4_440_105_000 picoseconds. + Weight::from_parts(4_189_326_223, 0) + // Standard Error: 94_884 + .saturating_add(Weight::from_parts(5_283_060, 0).saturating_mul(r.into())) } /// The range of component `r` is `[50, 500]`. fn instr_i64store(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 11_072_272_000 picoseconds. - Weight::from_parts(11_558_306_225, 0) - // Standard Error: 165_659 - .saturating_add(Weight::from_parts(9_828_260, 0).saturating_mul(r.into())) + // Minimum execution time: 11_389_557_000 picoseconds. + Weight::from_parts(11_860_510_711, 0) + // Standard Error: 156_021 + .saturating_add(Weight::from_parts(9_199_358, 0).saturating_mul(r.into())) } /// The range of component `r` is `[50, 500]`. fn instr_i32store(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 10_285_071_000 picoseconds. - Weight::from_parts(11_137_621_942, 0) - // Standard Error: 147_513 - .saturating_add(Weight::from_parts(9_014_757, 0).saturating_mul(r.into())) + // Minimum execution time: 11_497_103_000 picoseconds. + Weight::from_parts(11_330_880_436, 0) + // Standard Error: 132_247 + .saturating_add(Weight::from_parts(10_016_516, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_select(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_285_000 picoseconds. - Weight::from_parts(2_410_000, 0) - // Standard Error: 7_624 - .saturating_add(Weight::from_parts(3_864_490, 0).saturating_mul(r.into())) + // Minimum execution time: 2_381_000 picoseconds. + Weight::from_parts(2_444_000, 0) + // Standard Error: 7_402 + .saturating_add(Weight::from_parts(3_876_295, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_if(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_342_000 picoseconds. - Weight::from_parts(2_433_000, 0) - // Standard Error: 6_413 - .saturating_add(Weight::from_parts(3_120_732, 0).saturating_mul(r.into())) + // Minimum execution time: 2_405_000 picoseconds. + Weight::from_parts(481_308, 0) + // Standard Error: 8_161 + .saturating_add(Weight::from_parts(3_159_957, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_br(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_301_000 picoseconds. - Weight::from_parts(3_591_730, 0) - // Standard Error: 1_106 - .saturating_add(Weight::from_parts(1_565_415, 0).saturating_mul(r.into())) + // Minimum execution time: 2_371_000 picoseconds. + Weight::from_parts(3_249_787, 0) + // Standard Error: 1_586 + .saturating_add(Weight::from_parts(1_582_965, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_br_if(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_306_000 picoseconds. - Weight::from_parts(2_461_000, 0) - // Standard Error: 7_711 - .saturating_add(Weight::from_parts(2_932_880, 0).saturating_mul(r.into())) + // Minimum execution time: 2_216_000 picoseconds. + Weight::from_parts(2_300_000, 0) + // Standard Error: 6_757 + .saturating_add(Weight::from_parts(2_971_649, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_br_table(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_358_000 picoseconds. - Weight::from_parts(2_144_801, 0) - // Standard Error: 22_082 - .saturating_add(Weight::from_parts(5_266_139, 0).saturating_mul(r.into())) + // Minimum execution time: 2_259_000 picoseconds. + Weight::from_parts(2_872_259, 0) + // Standard Error: 19_834 + .saturating_add(Weight::from_parts(5_176_111, 0).saturating_mul(r.into())) } /// The range of component `e` is `[1, 256]`. fn instr_br_table_per_entry(e: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 6_803_000 picoseconds. - Weight::from_parts(5_374_690, 0) - // Standard Error: 1_699 - .saturating_add(Weight::from_parts(171_193, 0).saturating_mul(e.into())) + // Minimum execution time: 6_999_000 picoseconds. + Weight::from_parts(6_015_140, 0) + // Standard Error: 1_903 + .saturating_add(Weight::from_parts(170_143, 0).saturating_mul(e.into())) } /// The range of component `r` is `[0, 50]`. fn instr_call_const(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_431_000 picoseconds. - Weight::from_parts(4_875_813, 0) - // Standard Error: 8_258 - .saturating_add(Weight::from_parts(2_629_733, 0).saturating_mul(r.into())) + // Minimum execution time: 2_308_000 picoseconds. + Weight::from_parts(5_881_148, 0) + // Standard Error: 9_069 + .saturating_add(Weight::from_parts(2_574_099, 0).saturating_mul(r.into())) } fn instr_i64const(r: u32, ) -> Weight { Weight::from_parts(0, 0) - .saturating_add(Weight::from_parts(2_629_733 - - 2_421_700, 0).saturating_mul(r.into())) + .saturating_add(Weight::from_parts(2_574_099 - + 2_423_093, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_call(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_403_000 picoseconds. - Weight::from_parts(5_140_243, 0) - // Standard Error: 13_164 - .saturating_add(Weight::from_parts(2_421_700, 0).saturating_mul(r.into())) + // Minimum execution time: 2_337_000 picoseconds. + Weight::from_parts(5_123_036, 0) + // Standard Error: 12_143 + .saturating_add(Weight::from_parts(2_423_093, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_call_indirect(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_669_000 picoseconds. - Weight::from_parts(22_369_265, 0) - // Standard Error: 28_577 - .saturating_add(Weight::from_parts(9_740_558, 0).saturating_mul(r.into())) + // Minimum execution time: 2_736_000 picoseconds. + Weight::from_parts(16_600_828, 0) + // Standard Error: 30_025 + .saturating_add(Weight::from_parts(10_214_913, 0).saturating_mul(r.into())) } /// The range of component `p` is `[0, 128]`. fn instr_call_indirect_per_param(p: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 12_277_000 picoseconds. - Weight::from_parts(3_596_853, 0) - // Standard Error: 5_869 - .saturating_add(Weight::from_parts(1_258_605, 0).saturating_mul(p.into())) + // Minimum execution time: 12_483_000 picoseconds. + Weight::from_parts(1_416_669, 0) + // Standard Error: 5_995 + .saturating_add(Weight::from_parts(1_336_453, 0).saturating_mul(p.into())) } /// The range of component `l` is `[0, 1024]`. fn instr_call_per_local(_l: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 5_391_000 picoseconds. - Weight::from_parts(5_778_137, 0) + // Minimum execution time: 5_497_000 picoseconds. + Weight::from_parts(5_981_231, 0) } /// The range of component `r` is `[0, 50]`. fn instr_local_get(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 4_835_000 picoseconds. - Weight::from_parts(6_065_483, 0) - // Standard Error: 3_006 - .saturating_add(Weight::from_parts(378_512, 0).saturating_mul(r.into())) + // Minimum execution time: 4_730_000 picoseconds. + Weight::from_parts(5_851_529, 0) + // Standard Error: 2_642 + .saturating_add(Weight::from_parts(392_869, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_local_set(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 4_722_000 picoseconds. - Weight::from_parts(3_902_309, 0) - // Standard Error: 5_742 - .saturating_add(Weight::from_parts(1_056_408, 0).saturating_mul(r.into())) + // Minimum execution time: 4_837_000 picoseconds. + Weight::from_parts(4_473_635, 0) + // Standard Error: 5_210 + .saturating_add(Weight::from_parts(1_003_312, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_local_tee(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 4_888_000 picoseconds. - Weight::from_parts(4_512_058, 0) - // Standard Error: 6_410 - .saturating_add(Weight::from_parts(1_001_510, 0).saturating_mul(r.into())) + // Minimum execution time: 4_802_000 picoseconds. + Weight::from_parts(2_153_776, 0) + // Standard Error: 11_517 + .saturating_add(Weight::from_parts(1_186_032, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_global_get(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 6_413_000 picoseconds. - Weight::from_parts(2_704_134, 0) - // Standard Error: 7_244 - .saturating_add(Weight::from_parts(804_200, 0).saturating_mul(r.into())) + // Minimum execution time: 6_375_000 picoseconds. + Weight::from_parts(3_754_449, 0) + // Standard Error: 5_686 + .saturating_add(Weight::from_parts(763_597, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_global_set(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 6_516_000 picoseconds. - Weight::from_parts(1_028_752, 0) - // Standard Error: 8_792 - .saturating_add(Weight::from_parts(1_494_630, 0).saturating_mul(r.into())) + // Minimum execution time: 6_475_000 picoseconds. + Weight::from_parts(266_670, 0) + // Standard Error: 10_193 + .saturating_add(Weight::from_parts(1_552_777, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_memory_current(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 5_560_000 picoseconds. - Weight::from_parts(1_126_442, 0) - // Standard Error: 14_476 - .saturating_add(Weight::from_parts(7_240_597, 0).saturating_mul(r.into())) + // Minimum execution time: 6_887_000 picoseconds. + Weight::from_parts(4_333_544, 0) + // Standard Error: 10_173 + .saturating_add(Weight::from_parts(6_952_830, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64clz(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_299_000 picoseconds. - Weight::from_parts(2_449_000, 0) - // Standard Error: 7_416 - .saturating_add(Weight::from_parts(3_344_387, 0).saturating_mul(r.into())) + // Minimum execution time: 2_267_000 picoseconds. + Weight::from_parts(2_351_000, 0) + // Standard Error: 5_280 + .saturating_add(Weight::from_parts(3_360_413, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32clz(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_389_000 picoseconds. - Weight::from_parts(2_551_000, 0) - // Standard Error: 5_708 - .saturating_add(Weight::from_parts(3_133_430, 0).saturating_mul(r.into())) + // Minimum execution time: 2_283_000 picoseconds. + Weight::from_parts(2_357_000, 0) + // Standard Error: 4_452 + .saturating_add(Weight::from_parts(3_099_489, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64ctz(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_428_000 picoseconds. - Weight::from_parts(2_511_000, 0) - // Standard Error: 7_262 - .saturating_add(Weight::from_parts(3_192_675, 0).saturating_mul(r.into())) + // Minimum execution time: 2_328_000 picoseconds. + Weight::from_parts(2_417_000, 0) + // Standard Error: 5_054 + .saturating_add(Weight::from_parts(3_106_996, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32ctz(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_333_000 picoseconds. - Weight::from_parts(2_426_000, 0) - // Standard Error: 4_554 - .saturating_add(Weight::from_parts(2_683_293, 0).saturating_mul(r.into())) + // Minimum execution time: 2_230_000 picoseconds. + Weight::from_parts(2_296_000, 0) + // Standard Error: 3_924 + .saturating_add(Weight::from_parts(2_681_831, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64popcnt(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_334_000 picoseconds. - Weight::from_parts(2_385_000, 0) - // Standard Error: 4_686 - .saturating_add(Weight::from_parts(631_609, 0).saturating_mul(r.into())) + // Minimum execution time: 2_294_000 picoseconds. + Weight::from_parts(2_438_000, 0) + // Standard Error: 4_198 + .saturating_add(Weight::from_parts(603_106, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32popcnt(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_356_000 picoseconds. - Weight::from_parts(1_221_890, 0) - // Standard Error: 3_960 - .saturating_add(Weight::from_parts(452_047, 0).saturating_mul(r.into())) + // Minimum execution time: 2_257_000 picoseconds. + Weight::from_parts(2_121_941, 0) + // Standard Error: 3_525 + .saturating_add(Weight::from_parts(401_578, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64eqz(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_318_000 picoseconds. - Weight::from_parts(2_390_000, 0) - // Standard Error: 11_114 - .saturating_add(Weight::from_parts(1_916_122, 0).saturating_mul(r.into())) + // Minimum execution time: 2_224_000 picoseconds. + Weight::from_parts(2_291_000, 0) + // Standard Error: 9_436 + .saturating_add(Weight::from_parts(1_891_725, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32eqz(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_436_000 picoseconds. - Weight::from_parts(2_504_000, 0) - // Standard Error: 7_104 - .saturating_add(Weight::from_parts(1_156_958, 0).saturating_mul(r.into())) + // Minimum execution time: 2_273_000 picoseconds. + Weight::from_parts(2_417_000, 0) + // Standard Error: 8_255 + .saturating_add(Weight::from_parts(1_289_311, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32extend8s(r: u32, ) -> Weight { @@ -1510,631 +1512,631 @@ impl pallet_gear::WeightInfo for SubstrateWeight { // Measured: `0` // Estimated: `0` // Minimum execution time: 2_276_000 picoseconds. - Weight::from_parts(1_708_596, 0) - // Standard Error: 2_843 - .saturating_add(Weight::from_parts(377_083, 0).saturating_mul(r.into())) + Weight::from_parts(1_306_236, 0) + // Standard Error: 5_275 + .saturating_add(Weight::from_parts(426_430, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32extend16s(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_386_000 picoseconds. - Weight::from_parts(1_424_415, 0) - // Standard Error: 3_599 - .saturating_add(Weight::from_parts(395_934, 0).saturating_mul(r.into())) + // Minimum execution time: 2_341_000 picoseconds. + Weight::from_parts(1_669_540, 0) + // Standard Error: 4_902 + .saturating_add(Weight::from_parts(405_099, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64extend8s(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_396_000 picoseconds. - Weight::from_parts(2_491_000, 0) - // Standard Error: 3_774 - .saturating_add(Weight::from_parts(516_281, 0).saturating_mul(r.into())) + // Minimum execution time: 2_244_000 picoseconds. + Weight::from_parts(2_317_000, 0) + // Standard Error: 3_916 + .saturating_add(Weight::from_parts(552_354, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64extend16s(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_308_000 picoseconds. - Weight::from_parts(548_192, 0) - // Standard Error: 4_583 - .saturating_add(Weight::from_parts(556_734, 0).saturating_mul(r.into())) + // Minimum execution time: 2_316_000 picoseconds. + Weight::from_parts(2_395_000, 0) + // Standard Error: 5_375 + .saturating_add(Weight::from_parts(589_608, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64extend32s(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_333_000 picoseconds. - Weight::from_parts(447_271, 0) - // Standard Error: 5_300 - .saturating_add(Weight::from_parts(535_915, 0).saturating_mul(r.into())) + // Minimum execution time: 2_258_000 picoseconds. + Weight::from_parts(98_911, 0) + // Standard Error: 7_257 + .saturating_add(Weight::from_parts(581_834, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64extendsi32(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_340_000 picoseconds. - Weight::from_parts(1_639_695, 0) - // Standard Error: 3_519 - .saturating_add(Weight::from_parts(368_523, 0).saturating_mul(r.into())) + // Minimum execution time: 2_293_000 picoseconds. + Weight::from_parts(1_730_402, 0) + // Standard Error: 4_194 + .saturating_add(Weight::from_parts(357_287, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64extendui32(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_305_000 picoseconds. - Weight::from_parts(2_843_474, 0) - // Standard Error: 1_950 - .saturating_add(Weight::from_parts(176_592, 0).saturating_mul(r.into())) + // Minimum execution time: 2_580_000 picoseconds. + Weight::from_parts(2_927_247, 0) + // Standard Error: 2_012 + .saturating_add(Weight::from_parts(181_106, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32wrapi64(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_351_000 picoseconds. - Weight::from_parts(2_894_613, 0) - // Standard Error: 2_024 - .saturating_add(Weight::from_parts(188_853, 0).saturating_mul(r.into())) + // Minimum execution time: 2_308_000 picoseconds. + Weight::from_parts(2_742_236, 0) + // Standard Error: 2_482 + .saturating_add(Weight::from_parts(187_830, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64eq(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_353_000 picoseconds. - Weight::from_parts(2_418_000, 0) - // Standard Error: 9_504 - .saturating_add(Weight::from_parts(1_936_605, 0).saturating_mul(r.into())) + // Minimum execution time: 2_324_000 picoseconds. + Weight::from_parts(2_385_000, 0) + // Standard Error: 9_154 + .saturating_add(Weight::from_parts(1_858_617, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32eq(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_291_000 picoseconds. - Weight::from_parts(2_364_000, 0) - // Standard Error: 8_346 - .saturating_add(Weight::from_parts(1_222_521, 0).saturating_mul(r.into())) + // Minimum execution time: 2_237_000 picoseconds. + Weight::from_parts(2_302_000, 0) + // Standard Error: 7_801 + .saturating_add(Weight::from_parts(1_226_411, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64ne(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_345_000 picoseconds. - Weight::from_parts(2_452_000, 0) - // Standard Error: 10_232 - .saturating_add(Weight::from_parts(1_883_867, 0).saturating_mul(r.into())) + // Minimum execution time: 2_265_000 picoseconds. + Weight::from_parts(2_358_000, 0) + // Standard Error: 9_102 + .saturating_add(Weight::from_parts(1_866_723, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32ne(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_323_000 picoseconds. - Weight::from_parts(2_387_000, 0) - // Standard Error: 7_581 - .saturating_add(Weight::from_parts(1_200_178, 0).saturating_mul(r.into())) + // Minimum execution time: 2_267_000 picoseconds. + Weight::from_parts(2_381_000, 0) + // Standard Error: 8_629 + .saturating_add(Weight::from_parts(1_209_968, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64lts(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_410_000 picoseconds. - Weight::from_parts(2_459_000, 0) - // Standard Error: 11_139 - .saturating_add(Weight::from_parts(1_877_766, 0).saturating_mul(r.into())) + // Minimum execution time: 2_274_000 picoseconds. + Weight::from_parts(2_330_000, 0) + // Standard Error: 9_193 + .saturating_add(Weight::from_parts(1_895_140, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32lts(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_273_000 picoseconds. - Weight::from_parts(2_387_000, 0) - // Standard Error: 8_083 - .saturating_add(Weight::from_parts(1_217_904, 0).saturating_mul(r.into())) + // Minimum execution time: 2_306_000 picoseconds. + Weight::from_parts(2_394_000, 0) + // Standard Error: 7_780 + .saturating_add(Weight::from_parts(1_209_776, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64ltu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_403_000 picoseconds. - Weight::from_parts(2_482_000, 0) - // Standard Error: 11_044 - .saturating_add(Weight::from_parts(1_956_302, 0).saturating_mul(r.into())) + // Minimum execution time: 2_273_000 picoseconds. + Weight::from_parts(2_395_000, 0) + // Standard Error: 8_868 + .saturating_add(Weight::from_parts(1_845_417, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32ltu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_353_000 picoseconds. - Weight::from_parts(2_420_000, 0) - // Standard Error: 7_870 - .saturating_add(Weight::from_parts(1_213_570, 0).saturating_mul(r.into())) + // Minimum execution time: 2_280_000 picoseconds. + Weight::from_parts(2_360_000, 0) + // Standard Error: 8_139 + .saturating_add(Weight::from_parts(1_208_611, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64gts(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_364_000 picoseconds. - Weight::from_parts(2_430_000, 0) - // Standard Error: 10_577 - .saturating_add(Weight::from_parts(1_968_043, 0).saturating_mul(r.into())) + // Minimum execution time: 2_299_000 picoseconds. + Weight::from_parts(2_335_000, 0) + // Standard Error: 8_008 + .saturating_add(Weight::from_parts(1_833_636, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32gts(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_328_000 picoseconds. - Weight::from_parts(2_442_000, 0) - // Standard Error: 7_838 - .saturating_add(Weight::from_parts(1_267_211, 0).saturating_mul(r.into())) + // Minimum execution time: 2_222_000 picoseconds. + Weight::from_parts(2_376_000, 0) + // Standard Error: 7_996 + .saturating_add(Weight::from_parts(1_224_203, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64gtu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_395_000 picoseconds. - Weight::from_parts(2_460_000, 0) - // Standard Error: 10_856 - .saturating_add(Weight::from_parts(1_910_357, 0).saturating_mul(r.into())) + // Minimum execution time: 2_371_000 picoseconds. + Weight::from_parts(2_421_000, 0) + // Standard Error: 9_119 + .saturating_add(Weight::from_parts(1_821_158, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32gtu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_343_000 picoseconds. - Weight::from_parts(2_409_000, 0) - // Standard Error: 5_786 - .saturating_add(Weight::from_parts(1_128_653, 0).saturating_mul(r.into())) + // Minimum execution time: 2_305_000 picoseconds. + Weight::from_parts(2_418_000, 0) + // Standard Error: 7_441 + .saturating_add(Weight::from_parts(1_186_995, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64les(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_318_000 picoseconds. - Weight::from_parts(2_433_000, 0) - // Standard Error: 10_344 - .saturating_add(Weight::from_parts(1_897_480, 0).saturating_mul(r.into())) + // Minimum execution time: 2_340_000 picoseconds. + Weight::from_parts(2_362_000, 0) + // Standard Error: 8_788 + .saturating_add(Weight::from_parts(1_811_701, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32les(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_355_000 picoseconds. - Weight::from_parts(2_460_000, 0) - // Standard Error: 6_963 - .saturating_add(Weight::from_parts(1_125_698, 0).saturating_mul(r.into())) + // Minimum execution time: 2_352_000 picoseconds. + Weight::from_parts(2_431_000, 0) + // Standard Error: 6_620 + .saturating_add(Weight::from_parts(1_171_906, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64leu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_356_000 picoseconds. - Weight::from_parts(2_447_000, 0) - // Standard Error: 8_285 - .saturating_add(Weight::from_parts(1_848_149, 0).saturating_mul(r.into())) + // Minimum execution time: 2_352_000 picoseconds. + Weight::from_parts(2_380_000, 0) + // Standard Error: 8_554 + .saturating_add(Weight::from_parts(1_821_955, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32leu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_327_000 picoseconds. - Weight::from_parts(2_394_000, 0) - // Standard Error: 7_282 - .saturating_add(Weight::from_parts(1_176_423, 0).saturating_mul(r.into())) + // Minimum execution time: 2_299_000 picoseconds. + Weight::from_parts(2_389_000, 0) + // Standard Error: 7_710 + .saturating_add(Weight::from_parts(1_188_722, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64ges(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_372_000 picoseconds. - Weight::from_parts(2_439_000, 0) - // Standard Error: 9_207 - .saturating_add(Weight::from_parts(1_837_009, 0).saturating_mul(r.into())) + // Minimum execution time: 2_325_000 picoseconds. + Weight::from_parts(2_387_000, 0) + // Standard Error: 10_150 + .saturating_add(Weight::from_parts(1_912_877, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32ges(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_368_000 picoseconds. - Weight::from_parts(2_427_000, 0) - // Standard Error: 8_320 - .saturating_add(Weight::from_parts(1_231_088, 0).saturating_mul(r.into())) + // Minimum execution time: 2_377_000 picoseconds. + Weight::from_parts(2_423_000, 0) + // Standard Error: 6_824 + .saturating_add(Weight::from_parts(1_181_831, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64geu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_373_000 picoseconds. - Weight::from_parts(2_461_000, 0) - // Standard Error: 9_499 - .saturating_add(Weight::from_parts(1_922_588, 0).saturating_mul(r.into())) + // Minimum execution time: 2_292_000 picoseconds. + Weight::from_parts(2_384_000, 0) + // Standard Error: 9_214 + .saturating_add(Weight::from_parts(1_842_825, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32geu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_387_000 picoseconds. - Weight::from_parts(2_455_000, 0) - // Standard Error: 7_681 - .saturating_add(Weight::from_parts(1_198_894, 0).saturating_mul(r.into())) + // Minimum execution time: 2_283_000 picoseconds. + Weight::from_parts(2_344_000, 0) + // Standard Error: 7_145 + .saturating_add(Weight::from_parts(1_216_207, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64add(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_308_000 picoseconds. - Weight::from_parts(2_389_000, 0) - // Standard Error: 7_797 - .saturating_add(Weight::from_parts(1_286_566, 0).saturating_mul(r.into())) + // Minimum execution time: 2_232_000 picoseconds. + Weight::from_parts(2_391_000, 0) + // Standard Error: 9_159 + .saturating_add(Weight::from_parts(1_360_135, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32add(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_329_000 picoseconds. - Weight::from_parts(2_389_000, 0) - // Standard Error: 4_968 - .saturating_add(Weight::from_parts(645_254, 0).saturating_mul(r.into())) + // Minimum execution time: 2_279_000 picoseconds. + Weight::from_parts(2_379_000, 0) + // Standard Error: 5_400 + .saturating_add(Weight::from_parts(704_012, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64sub(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_409_000 picoseconds. - Weight::from_parts(2_489_000, 0) - // Standard Error: 7_055 - .saturating_add(Weight::from_parts(1_232_084, 0).saturating_mul(r.into())) + // Minimum execution time: 2_355_000 picoseconds. + Weight::from_parts(2_402_000, 0) + // Standard Error: 8_632 + .saturating_add(Weight::from_parts(1_358_130, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32sub(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_371_000 picoseconds. - Weight::from_parts(2_420_000, 0) - // Standard Error: 4_348 - .saturating_add(Weight::from_parts(633_810, 0).saturating_mul(r.into())) + // Minimum execution time: 2_365_000 picoseconds. + Weight::from_parts(2_389_000, 0) + // Standard Error: 4_840 + .saturating_add(Weight::from_parts(658_882, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64mul(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_336_000 picoseconds. - Weight::from_parts(2_413_000, 0) - // Standard Error: 8_202 - .saturating_add(Weight::from_parts(1_777_425, 0).saturating_mul(r.into())) + // Minimum execution time: 2_209_000 picoseconds. + Weight::from_parts(2_324_000, 0) + // Standard Error: 8_679 + .saturating_add(Weight::from_parts(1_840_263, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32mul(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_314_000 picoseconds. - Weight::from_parts(2_369_000, 0) - // Standard Error: 6_935 - .saturating_add(Weight::from_parts(1_201_570, 0).saturating_mul(r.into())) + // Minimum execution time: 2_258_000 picoseconds. + Weight::from_parts(2_382_000, 0) + // Standard Error: 7_484 + .saturating_add(Weight::from_parts(1_255_185, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64divs(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_276_000 picoseconds. - Weight::from_parts(6_846_840, 0) - // Standard Error: 17_822 - .saturating_add(Weight::from_parts(2_268_370, 0).saturating_mul(r.into())) + // Minimum execution time: 2_369_000 picoseconds. + Weight::from_parts(6_412_885, 0) + // Standard Error: 22_130 + .saturating_add(Weight::from_parts(2_376_785, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32divs(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_394_000 picoseconds. - Weight::from_parts(4_704_336, 0) - // Standard Error: 10_960 - .saturating_add(Weight::from_parts(2_182_711, 0).saturating_mul(r.into())) + // Minimum execution time: 2_266_000 picoseconds. + Weight::from_parts(2_981_330, 0) + // Standard Error: 11_996 + .saturating_add(Weight::from_parts(2_322_763, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64divu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_375_000 picoseconds. - Weight::from_parts(1_968_824, 0) - // Standard Error: 15_899 - .saturating_add(Weight::from_parts(2_762_269, 0).saturating_mul(r.into())) + // Minimum execution time: 2_240_000 picoseconds. + Weight::from_parts(7_628_007, 0) + // Standard Error: 29_510 + .saturating_add(Weight::from_parts(2_483_957, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32divu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_335_000 picoseconds. - Weight::from_parts(1_450_000, 0) - // Standard Error: 13_496 - .saturating_add(Weight::from_parts(2_401_407, 0).saturating_mul(r.into())) + // Minimum execution time: 2_387_000 picoseconds. + Weight::from_parts(4_910_027, 0) + // Standard Error: 23_548 + .saturating_add(Weight::from_parts(2_233_487, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64rems(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_448_000 picoseconds. - Weight::from_parts(2_513_000, 0) - // Standard Error: 19_401 - .saturating_add(Weight::from_parts(9_309_211, 0).saturating_mul(r.into())) + // Minimum execution time: 2_297_000 picoseconds. + Weight::from_parts(16_240_633, 0) + // Standard Error: 67_100 + .saturating_add(Weight::from_parts(8_506_720, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32rems(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_273_000 picoseconds. - Weight::from_parts(1_738_370, 0) - // Standard Error: 42_672 - .saturating_add(Weight::from_parts(7_512_557, 0).saturating_mul(r.into())) + // Minimum execution time: 2_234_000 picoseconds. + Weight::from_parts(2_498_693, 0) + // Standard Error: 48_996 + .saturating_add(Weight::from_parts(7_513_162, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64remu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_371_000 picoseconds. - Weight::from_parts(2_215_088, 0) - // Standard Error: 15_445 - .saturating_add(Weight::from_parts(2_956_278, 0).saturating_mul(r.into())) + // Minimum execution time: 2_221_000 picoseconds. + Weight::from_parts(5_074_264, 0) + // Standard Error: 23_109 + .saturating_add(Weight::from_parts(2_727_269, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32remu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_409_000 picoseconds. - Weight::from_parts(217_500, 0) - // Standard Error: 7_904 - .saturating_add(Weight::from_parts(2_576_151, 0).saturating_mul(r.into())) + // Minimum execution time: 2_283_000 picoseconds. + Weight::from_parts(2_057_554, 0) + // Standard Error: 15_404 + .saturating_add(Weight::from_parts(2_428_553, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64and(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_456_000 picoseconds. - Weight::from_parts(2_503_000, 0) - // Standard Error: 7_920 - .saturating_add(Weight::from_parts(1_321_543, 0).saturating_mul(r.into())) + // Minimum execution time: 2_250_000 picoseconds. + Weight::from_parts(2_359_000, 0) + // Standard Error: 8_133 + .saturating_add(Weight::from_parts(1_333_125, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32and(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_346_000 picoseconds. - Weight::from_parts(2_479_000, 0) - // Standard Error: 4_711 - .saturating_add(Weight::from_parts(689_892, 0).saturating_mul(r.into())) + // Minimum execution time: 2_251_000 picoseconds. + Weight::from_parts(2_372_000, 0) + // Standard Error: 4_205 + .saturating_add(Weight::from_parts(671_074, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64or(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_339_000 picoseconds. - Weight::from_parts(2_427_000, 0) - // Standard Error: 8_029 - .saturating_add(Weight::from_parts(1_256_838, 0).saturating_mul(r.into())) + // Minimum execution time: 2_257_000 picoseconds. + Weight::from_parts(2_323_000, 0) + // Standard Error: 7_098 + .saturating_add(Weight::from_parts(1_323_703, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32or(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_334_000 picoseconds. - Weight::from_parts(2_480_000, 0) - // Standard Error: 3_812 - .saturating_add(Weight::from_parts(607_420, 0).saturating_mul(r.into())) + // Minimum execution time: 2_247_000 picoseconds. + Weight::from_parts(2_372_000, 0) + // Standard Error: 6_649 + .saturating_add(Weight::from_parts(695_117, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64xor(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_328_000 picoseconds. - Weight::from_parts(2_392_000, 0) - // Standard Error: 7_362 - .saturating_add(Weight::from_parts(1_248_739, 0).saturating_mul(r.into())) + // Minimum execution time: 2_293_000 picoseconds. + Weight::from_parts(2_347_000, 0) + // Standard Error: 7_359 + .saturating_add(Weight::from_parts(1_355_885, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32xor(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_419_000 picoseconds. - Weight::from_parts(2_465_000, 0) - // Standard Error: 4_304 - .saturating_add(Weight::from_parts(604_813, 0).saturating_mul(r.into())) + // Minimum execution time: 2_239_000 picoseconds. + Weight::from_parts(2_335_000, 0) + // Standard Error: 4_076 + .saturating_add(Weight::from_parts(658_834, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64shl(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_298_000 picoseconds. - Weight::from_parts(2_433_000, 0) - // Standard Error: 8_043 - .saturating_add(Weight::from_parts(1_073_194, 0).saturating_mul(r.into())) + // Minimum execution time: 2_376_000 picoseconds. + Weight::from_parts(2_444_000, 0) + // Standard Error: 6_850 + .saturating_add(Weight::from_parts(1_191_253, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32shl(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_427_000 picoseconds. - Weight::from_parts(2_511_000, 0) - // Standard Error: 4_969 - .saturating_add(Weight::from_parts(594_802, 0).saturating_mul(r.into())) + // Minimum execution time: 2_240_000 picoseconds. + Weight::from_parts(2_310_000, 0) + // Standard Error: 4_398 + .saturating_add(Weight::from_parts(597_162, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64shrs(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_312_000 picoseconds. - Weight::from_parts(2_399_000, 0) - // Standard Error: 7_093 - .saturating_add(Weight::from_parts(1_110_114, 0).saturating_mul(r.into())) + // Minimum execution time: 2_338_000 picoseconds. + Weight::from_parts(2_421_000, 0) + // Standard Error: 8_320 + .saturating_add(Weight::from_parts(1_163_071, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32shrs(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_331_000 picoseconds. - Weight::from_parts(2_433_000, 0) - // Standard Error: 4_140 - .saturating_add(Weight::from_parts(600_354, 0).saturating_mul(r.into())) + // Minimum execution time: 2_376_000 picoseconds. + Weight::from_parts(2_464_000, 0) + // Standard Error: 5_750 + .saturating_add(Weight::from_parts(613_283, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64shru(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_300_000 picoseconds. - Weight::from_parts(2_419_000, 0) - // Standard Error: 7_150 - .saturating_add(Weight::from_parts(1_154_649, 0).saturating_mul(r.into())) + // Minimum execution time: 2_338_000 picoseconds. + Weight::from_parts(2_378_000, 0) + // Standard Error: 7_893 + .saturating_add(Weight::from_parts(1_161_655, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32shru(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_356_000 picoseconds. - Weight::from_parts(2_423_000, 0) - // Standard Error: 5_067 - .saturating_add(Weight::from_parts(594_487, 0).saturating_mul(r.into())) + // Minimum execution time: 2_260_000 picoseconds. + Weight::from_parts(2_351_000, 0) + // Standard Error: 3_972 + .saturating_add(Weight::from_parts(605_013, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64rotl(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_339_000 picoseconds. - Weight::from_parts(2_406_000, 0) - // Standard Error: 5_674 - .saturating_add(Weight::from_parts(1_051_819, 0).saturating_mul(r.into())) + // Minimum execution time: 2_324_000 picoseconds. + Weight::from_parts(2_375_000, 0) + // Standard Error: 7_329 + .saturating_add(Weight::from_parts(1_108_542, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32rotl(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_383_000 picoseconds. - Weight::from_parts(114_723, 0) - // Standard Error: 5_881 - .saturating_add(Weight::from_parts(646_798, 0).saturating_mul(r.into())) + // Minimum execution time: 2_342_000 picoseconds. + Weight::from_parts(2_465_000, 0) + // Standard Error: 5_553 + .saturating_add(Weight::from_parts(617_389, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64rotr(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_292_000 picoseconds. - Weight::from_parts(2_422_000, 0) - // Standard Error: 6_697 - .saturating_add(Weight::from_parts(1_053_580, 0).saturating_mul(r.into())) + // Minimum execution time: 2_260_000 picoseconds. + Weight::from_parts(2_419_000, 0) + // Standard Error: 8_448 + .saturating_add(Weight::from_parts(1_105_239, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32rotr(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_325_000 picoseconds. - Weight::from_parts(206_699, 0) - // Standard Error: 5_851 - .saturating_add(Weight::from_parts(639_333, 0).saturating_mul(r.into())) + // Minimum execution time: 2_255_000 picoseconds. + Weight::from_parts(2_321_000, 0) + // Standard Error: 5_862 + .saturating_add(Weight::from_parts(626_497, 0).saturating_mul(r.into())) } fn tasks_remove_resume_session() -> Weight { // Proof Size summary in bytes: // Measured: `352` // Estimated: `4169` - // Minimum execution time: 5_698_000 picoseconds. - Weight::from_parts(5_953_000, 4169) + // Minimum execution time: 5_780_000 picoseconds. + Weight::from_parts(6_083_000, 4169) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) } fn tasks_remove_gas_reservation() -> Weight { // Proof Size summary in bytes: - // Measured: `1003` - // Estimated: `23637` - // Minimum execution time: 61_615_000 picoseconds. - Weight::from_parts(64_309_000, 23637) + // Measured: `1039` + // Estimated: `23781` + // Minimum execution time: 62_100_000 picoseconds. + Weight::from_parts(64_771_000, 23781) .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().writes(6_u64)) } fn tasks_send_user_message_to_mailbox() -> Weight { // Proof Size summary in bytes: - // Measured: `784` - // Estimated: `21534` - // Minimum execution time: 43_449_000 picoseconds. - Weight::from_parts(44_990_000, 21534) + // Measured: `820` + // Estimated: `21750` + // Minimum execution time: 47_415_000 picoseconds. + Weight::from_parts(48_906_000, 21750) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().writes(5_u64)) } fn tasks_send_user_message() -> Weight { // Proof Size summary in bytes: - // Measured: `906` - // Estimated: `33891` - // Minimum execution time: 75_764_000 picoseconds. - Weight::from_parts(77_875_000, 33891) + // Measured: `942` + // Estimated: `34143` + // Minimum execution time: 76_882_000 picoseconds. + Weight::from_parts(79_728_000, 34143) .saturating_add(T::DbWeight::get().reads(11_u64)) .saturating_add(T::DbWeight::get().writes(10_u64)) } fn tasks_send_dispatch() -> Weight { // Proof Size summary in bytes: - // Measured: `591` - // Estimated: `19885` - // Minimum execution time: 31_362_000 picoseconds. - Weight::from_parts(32_425_000, 19885) + // Measured: `627` + // Estimated: `20101` + // Minimum execution time: 32_342_000 picoseconds. + Weight::from_parts(33_851_000, 20101) .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().writes(6_u64)) } fn tasks_wake_message() -> Weight { // Proof Size summary in bytes: - // Measured: `872` - // Estimated: `25908` - // Minimum execution time: 45_023_000 picoseconds. - Weight::from_parts(46_479_000, 25908) + // Measured: `908` + // Estimated: `26160` + // Minimum execution time: 50_697_000 picoseconds. + Weight::from_parts(53_632_000, 26160) .saturating_add(T::DbWeight::get().reads(8_u64)) .saturating_add(T::DbWeight::get().writes(6_u64)) } @@ -2142,37 +2144,37 @@ impl pallet_gear::WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `80` // Estimated: `3545` - // Minimum execution time: 3_365_000 picoseconds. - Weight::from_parts(3_639_000, 3545) + // Minimum execution time: 3_467_000 picoseconds. + Weight::from_parts(3_690_000, 3545) .saturating_add(T::DbWeight::get().reads(1_u64)) } fn tasks_remove_from_waitlist() -> Weight { // Proof Size summary in bytes: - // Measured: `1522` - // Estimated: `57192` - // Minimum execution time: 114_023_000 picoseconds. - Weight::from_parts(117_157_000, 57192) + // Measured: `1558` + // Estimated: `57552` + // Minimum execution time: 111_822_000 picoseconds. + Weight::from_parts(115_245_000, 57552) .saturating_add(T::DbWeight::get().reads(16_u64)) .saturating_add(T::DbWeight::get().writes(13_u64)) } fn tasks_remove_from_mailbox() -> Weight { // Proof Size summary in bytes: - // Measured: `1228` - // Estimated: `46026` - // Minimum execution time: 90_320_000 picoseconds. - Weight::from_parts(93_096_000, 46026) + // Measured: `1264` + // Estimated: `46350` + // Minimum execution time: 92_407_000 picoseconds. + Weight::from_parts(95_840_000, 46350) .saturating_add(T::DbWeight::get().reads(14_u64)) .saturating_add(T::DbWeight::get().writes(13_u64)) } /// The range of component `c` is `[0, 2044]`. fn tasks_pause_program(c: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `2200 + c * (16400 ±0)` - // Estimated: `19363 + c * (84480 ±0)` - // Minimum execution time: 28_326_000 picoseconds. - Weight::from_parts(28_612_000, 19363) - // Standard Error: 73_191 - .saturating_add(Weight::from_parts(39_403_570, 0).saturating_mul(c.into())) + // Measured: `2236 + c * (16400 ±0)` + // Estimated: `19543 + c * (84480 ±0)` + // Minimum execution time: 29_880_000 picoseconds. + Weight::from_parts(30_555_000, 19543) + // Standard Error: 65_806 + .saturating_add(Weight::from_parts(39_128_234, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(4_u64)) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(c.into()))) .saturating_add(T::DbWeight::get().writes(2_u64)) @@ -2182,12 +2184,12 @@ impl pallet_gear::WeightInfo for SubstrateWeight { /// The range of component `c` is `[0, 2044]`. fn tasks_pause_program_uninited(c: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `3025 + c * (42 ±0)` - // Estimated: `59431 + c * (2947 ±0)` - // Minimum execution time: 86_517_000 picoseconds. - Weight::from_parts(78_047_954, 59431) - // Standard Error: 2_660 - .saturating_add(Weight::from_parts(1_060_607, 0).saturating_mul(c.into())) + // Measured: `3061 + c * (42 ±0)` + // Estimated: `59827 + c * (2947 ±0)` + // Minimum execution time: 89_781_000 picoseconds. + Weight::from_parts(109_193_287, 59827) + // Standard Error: 2_877 + .saturating_add(Weight::from_parts(1_067_792, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(13_u64)) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(c.into()))) .saturating_add(T::DbWeight::get().writes(9_u64)) @@ -2198,6 +2200,136 @@ impl pallet_gear::WeightInfo for SubstrateWeight { // For backwards compatibility and tests impl WeightInfo for () { + /// The range of component `r` is `[0, 1]`. + fn gr_reply(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 94_792_000 picoseconds. + Weight::from_parts(103_063_604, 0) + // Standard Error: 103_375 + .saturating_add(Weight::from_parts(18_929_072, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_reply_wgas(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 96_154_000 picoseconds. + Weight::from_parts(107_249_232, 0) + // Standard Error: 99_969 + .saturating_add(Weight::from_parts(19_062_846, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_reply_commit(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 98_701_000 picoseconds. + Weight::from_parts(109_478_842, 0) + // Standard Error: 104_175 + .saturating_add(Weight::from_parts(10_887_124, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_reply_commit_wgas(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 102_910_000 picoseconds. + Weight::from_parts(109_181_566, 0) + // Standard Error: 81_801 + .saturating_add(Weight::from_parts(12_077_508, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_reply_input(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 719_481_000 picoseconds. + Weight::from_parts(765_485_196, 0) + // Standard Error: 676_170 + .saturating_add(Weight::from_parts(17_778_524, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_reply_input_wgas(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 720_914_000 picoseconds. + Weight::from_parts(776_554_516, 0) + // Standard Error: 1_018_495 + .saturating_add(Weight::from_parts(38_306_948, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_reservation_reply(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 105_823_000 picoseconds. + Weight::from_parts(112_820_586, 0) + // Standard Error: 82_530 + .saturating_add(Weight::from_parts(14_370_506, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_reservation_reply_commit(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 102_415_000 picoseconds. + Weight::from_parts(110_005_402, 0) + // Standard Error: 87_514 + .saturating_add(Weight::from_parts(6_578_880, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_exit(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 96_593_000 picoseconds. + Weight::from_parts(104_873_732, 0) + // Standard Error: 2_095_391 + .saturating_add(Weight::from_parts(193_359_282, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_leave(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 93_619_000 picoseconds. + Weight::from_parts(99_623_244, 0) + // Standard Error: 1_945_328 + .saturating_add(Weight::from_parts(179_784_494, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_wait(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 92_936_000 picoseconds. + Weight::from_parts(100_139_452, 0) + // Standard Error: 1_753_555 + .saturating_add(Weight::from_parts(132_465_876, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_wait_for(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 93_955_000 picoseconds. + Weight::from_parts(100_650_632, 0) + // Standard Error: 2_018_388 + .saturating_add(Weight::from_parts(178_916_382, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_wait_up_to(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 95_467_000 picoseconds. + Weight::from_parts(102_532_790, 0) + // Standard Error: 2_065_180 + .saturating_add(Weight::from_parts(187_152_790, 0).saturating_mul(r.into())) + } fn allocation_cost() -> Weight { // To be changed with the proper value. RocksDbWeight::get().writes(1) @@ -2217,21 +2349,21 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_023_000 picoseconds. - Weight::from_parts(1_051_000, 0) - // Standard Error: 912 - .saturating_add(Weight::from_parts(213_761, 0).saturating_mul(c.into())) + // Minimum execution time: 1_040_000 picoseconds. + Weight::from_parts(1_087_000, 0) + // Standard Error: 940 + .saturating_add(Weight::from_parts(251_751, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().writes(1_u64)) } /// The range of component `c` is `[0, 512]`. fn db_read_per_kb(c: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `146 + c * (1024 ±0)` - // Estimated: `3610 + c * (1024 ±0)` - // Minimum execution time: 3_252_000 picoseconds. - Weight::from_parts(3_416_000, 3610) - // Standard Error: 1_261 - .saturating_add(Weight::from_parts(689_572, 0).saturating_mul(c.into())) + // Measured: `79 + c * (1024 ±0)` + // Estimated: `3543 + c * (1024 ±0)` + // Minimum execution time: 3_333_000 picoseconds. + Weight::from_parts(3_463_000, 3543) + // Standard Error: 966 + .saturating_add(Weight::from_parts(678_430, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(Weight::from_parts(0, 1024).saturating_mul(c.into())) } @@ -2240,35 +2372,35 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 59_805_000 picoseconds. - Weight::from_parts(86_729_126, 0) - // Standard Error: 7_023 - .saturating_add(Weight::from_parts(2_475_519, 0).saturating_mul(c.into())) + // Minimum execution time: 61_586_000 picoseconds. + Weight::from_parts(95_956_778, 0) + // Standard Error: 5_472 + .saturating_add(Weight::from_parts(2_353_352, 0).saturating_mul(c.into())) } fn claim_value() -> Weight { // Proof Size summary in bytes: - // Measured: `1372` - // Estimated: `51905` - // Minimum execution time: 107_694_000 picoseconds. - Weight::from_parts(110_328_000, 51905) + // Measured: `1304` + // Estimated: `51293` + // Minimum execution time: 105_420_000 picoseconds. + Weight::from_parts(109_120_000, 51293) .saturating_add(RocksDbWeight::get().reads(15_u64)) .saturating_add(RocksDbWeight::get().writes(12_u64)) } fn pay_program_rent() -> Weight { // Proof Size summary in bytes: - // Measured: `992` - // Estimated: `21579` - // Minimum execution time: 55_980_000 picoseconds. - Weight::from_parts(56_766_000, 21579) + // Measured: `923` + // Estimated: `21372` + // Minimum execution time: 54_290_000 picoseconds. + Weight::from_parts(55_929_000, 21372) .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().writes(6_u64)) } fn resume_session_init() -> Weight { // Proof Size summary in bytes: - // Measured: `638` - // Estimated: `17486` - // Minimum execution time: 29_973_000 picoseconds. - Weight::from_parts(31_008_000, 17486) + // Measured: `570` + // Estimated: `17214` + // Minimum execution time: 29_539_000 picoseconds. + Weight::from_parts(30_515_000, 17214) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().writes(4_u64)) } @@ -2277,22 +2409,22 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `355` // Estimated: `7640` - // Minimum execution time: 8_054_000 picoseconds. - Weight::from_parts(8_342_000, 7640) - // Standard Error: 17_771 - .saturating_add(Weight::from_parts(13_335_661, 0).saturating_mul(c.into())) + // Minimum execution time: 8_426_000 picoseconds. + Weight::from_parts(5_984_423, 7640) + // Standard Error: 33_789 + .saturating_add(Weight::from_parts(13_895_151, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) } /// The range of component `c` is `[0, 2044]`. fn resume_session_commit(c: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `1593 + c * (16389 ±0)` - // Estimated: `43266 + c * (131112 ±0)` - // Minimum execution time: 72_178_000 picoseconds. - Weight::from_parts(73_341_000, 43266) - // Standard Error: 167_723 - .saturating_add(Weight::from_parts(54_442_045, 0).saturating_mul(c.into())) + // Measured: `1457 + c * (16389 ±0)` + // Estimated: `42178 + c * (131112 ±0)` + // Minimum execution time: 71_198_000 picoseconds. + Weight::from_parts(72_033_000, 42178) + // Standard Error: 159_543 + .saturating_add(Weight::from_parts(54_764_270, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(11_u64)) .saturating_add(RocksDbWeight::get().writes(9_u64)) .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(c.into()))) @@ -2301,24 +2433,24 @@ impl WeightInfo for () { /// The range of component `c` is `[0, 250]`. fn upload_code(c: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `113` - // Estimated: `5402` - // Minimum execution time: 78_662_000 picoseconds. - Weight::from_parts(42_066_175, 5402) - // Standard Error: 52_075 - .saturating_add(Weight::from_parts(60_249_549, 0).saturating_mul(c.into())) + // Measured: `46` + // Estimated: `5134` + // Minimum execution time: 77_259_000 picoseconds. + Weight::from_parts(52_968_469, 5134) + // Standard Error: 43_186 + .saturating_add(Weight::from_parts(59_988_588, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(4_u64)) } /// The range of component `s` is `[0, 4194304]`. fn create_program(s: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `1111` - // Estimated: `50600` - // Minimum execution time: 94_321_000 picoseconds. - Weight::from_parts(129_113_540, 50600) - // Standard Error: 1 - .saturating_add(Weight::from_parts(2_625, 0).saturating_mul(s.into())) + // Measured: `1043` + // Estimated: `49852` + // Minimum execution time: 96_734_000 picoseconds. + Weight::from_parts(136_364_170, 49852) + // Standard Error: 0 + .saturating_add(Weight::from_parts(2_592, 0).saturating_mul(s.into())) .saturating_add(RocksDbWeight::get().reads(15_u64)) .saturating_add(RocksDbWeight::get().writes(12_u64)) } @@ -2326,72 +2458,72 @@ impl WeightInfo for () { /// The range of component `s` is `[0, 4194304]`. fn upload_program(c: u32, s: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `521` - // Estimated: `45152` - // Minimum execution time: 11_148_491_000 picoseconds. - Weight::from_parts(21_065_971, 45152) - // Standard Error: 173_883 - .saturating_add(Weight::from_parts(60_839_567, 0).saturating_mul(c.into())) - // Standard Error: 10 - .saturating_add(Weight::from_parts(2_652, 0).saturating_mul(s.into())) + // Measured: `453` + // Estimated: `44268` + // Minimum execution time: 11_047_048_000 picoseconds. + Weight::from_parts(211_012_859, 44268) + // Standard Error: 157_221 + .saturating_add(Weight::from_parts(59_860_835, 0).saturating_mul(c.into())) + // Standard Error: 9 + .saturating_add(Weight::from_parts(2_554, 0).saturating_mul(s.into())) .saturating_add(RocksDbWeight::get().reads(15_u64)) .saturating_add(RocksDbWeight::get().writes(16_u64)) } /// The range of component `p` is `[0, 2097152]`. fn send_message(p: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `531` - // Estimated: `31266` - // Minimum execution time: 73_302_000 picoseconds. - Weight::from_parts(47_279_667, 31266) + // Measured: `530` + // Estimated: `31259` + // Minimum execution time: 73_682_000 picoseconds. + Weight::from_parts(48_414_295, 31259) // Standard Error: 1 - .saturating_add(Weight::from_parts(1_055, 0).saturating_mul(p.into())) + .saturating_add(Weight::from_parts(1_040, 0).saturating_mul(p.into())) .saturating_add(RocksDbWeight::get().reads(11_u64)) .saturating_add(RocksDbWeight::get().writes(10_u64)) } /// The range of component `p` is `[0, 2097152]`. fn send_reply(p: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `1371` - // Estimated: `54435` - // Minimum execution time: 124_173_000 picoseconds. - Weight::from_parts(96_458_887, 54435) - // Standard Error: 2 - .saturating_add(Weight::from_parts(1_078, 0).saturating_mul(p.into())) + // Measured: `1303` + // Estimated: `53823` + // Minimum execution time: 122_837_000 picoseconds. + Weight::from_parts(97_209_014, 53823) + // Standard Error: 1 + .saturating_add(Weight::from_parts(1_068, 0).saturating_mul(p.into())) .saturating_add(RocksDbWeight::get().reads(16_u64)) .saturating_add(RocksDbWeight::get().writes(13_u64)) } /// The range of component `q` is `[1, 512]`. fn initial_allocation(_q: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `1893` - // Estimated: `114612` - // Minimum execution time: 365_983_000 picoseconds. - Weight::from_parts(387_416_952, 114612) - .saturating_add(RocksDbWeight::get().reads(33_u64)) - .saturating_add(RocksDbWeight::get().writes(26_u64)) + // Measured: `979` + // Estimated: `89393` + // Minimum execution time: 354_207_000 picoseconds. + Weight::from_parts(374_297_966, 89393) + .saturating_add(RocksDbWeight::get().reads(31_u64)) + .saturating_add(RocksDbWeight::get().writes(24_u64)) } /// The range of component `q` is `[0, 512]`. fn alloc_in_handle(q: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `1893` - // Estimated: `114612` - // Minimum execution time: 380_430_000 picoseconds. - Weight::from_parts(403_376_118, 114612) - // Standard Error: 2_451 - .saturating_add(Weight::from_parts(1_137, 0).saturating_mul(q.into())) - .saturating_add(RocksDbWeight::get().reads(33_u64)) - .saturating_add(RocksDbWeight::get().writes(26_u64)) + // Measured: `979` + // Estimated: `89133` + // Minimum execution time: 368_424_000 picoseconds. + Weight::from_parts(387_073_481, 89133) + // Standard Error: 1_472 + .saturating_add(Weight::from_parts(4_343, 0).saturating_mul(q.into())) + .saturating_add(RocksDbWeight::get().reads(31_u64)) + .saturating_add(RocksDbWeight::get().writes(24_u64)) } /// The range of component `c` is `[0, 512]`. fn reinstrument_per_kb(c: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `211 + c * (1075 ±0)` // Estimated: `3899 + c * (2150 ±0)` - // Minimum execution time: 58_080_000 picoseconds. - Weight::from_parts(58_601_000, 3899) - // Standard Error: 36_083 - .saturating_add(Weight::from_parts(58_395_643, 0).saturating_mul(c.into())) + // Minimum execution time: 58_209_000 picoseconds. + Weight::from_parts(58_498_000, 3899) + // Standard Error: 35_860 + .saturating_add(Weight::from_parts(58_109_594, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) .saturating_add(Weight::from_parts(0, 2150).saturating_mul(c.into())) @@ -2401,638 +2533,510 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 91_412_000 picoseconds. - Weight::from_parts(94_168_000, 0) - // Standard Error: 3_806_298 - .saturating_add(Weight::from_parts(673_774_453, 0).saturating_mul(r.into())) + // Minimum execution time: 92_645_000 picoseconds. + Weight::from_parts(95_763_000, 0) + // Standard Error: 3_691_564 + .saturating_add(Weight::from_parts(713_537_659, 0).saturating_mul(r.into())) } /// The range of component `p` is `[1, 512]`. fn alloc_per_page(p: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 452_549_000 picoseconds. - Weight::from_parts(398_963_700, 0) - // Standard Error: 7_042 - .saturating_add(Weight::from_parts(29_406_609, 0).saturating_mul(p.into())) + // Minimum execution time: 495_006_000 picoseconds. + Weight::from_parts(421_459_793, 0) + // Standard Error: 9_156 + .saturating_add(Weight::from_parts(29_070_022, 0).saturating_mul(p.into())) } /// The range of component `r` is `[0, 20]`. fn free(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 207_052_000 picoseconds. - Weight::from_parts(209_606_478, 0) - // Standard Error: 255_281 - .saturating_add(Weight::from_parts(62_959_531, 0).saturating_mul(r.into())) + // Minimum execution time: 219_414_000 picoseconds. + Weight::from_parts(206_118_379, 0) + // Standard Error: 320_555 + .saturating_add(Weight::from_parts(64_665_141, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 256]`. fn gr_reserve_gas(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 97_729_000 picoseconds. - Weight::from_parts(105_964_750, 0) - // Standard Error: 4_847 - .saturating_add(Weight::from_parts(2_433_966, 0).saturating_mul(r.into())) + // Minimum execution time: 96_871_000 picoseconds. + Weight::from_parts(104_318_392, 0) + // Standard Error: 4_224 + .saturating_add(Weight::from_parts(2_443_618, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 256]`. fn gr_unreserve_gas(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 175_010_000 picoseconds. - Weight::from_parts(229_153_209, 0) - // Standard Error: 17_116 - .saturating_add(Weight::from_parts(1_991_260, 0).saturating_mul(r.into())) + // Minimum execution time: 152_658_000 picoseconds. + Weight::from_parts(218_177_774, 0) + // Standard Error: 23_640 + .saturating_add(Weight::from_parts(2_186_094, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_system_reserve_gas(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 94_696_000 picoseconds. - Weight::from_parts(119_674_535, 0) - // Standard Error: 387_178 - .saturating_add(Weight::from_parts(98_102_856, 0).saturating_mul(r.into())) + // Minimum execution time: 97_532_000 picoseconds. + Weight::from_parts(112_244_990, 0) + // Standard Error: 370_435 + .saturating_add(Weight::from_parts(102_977_688, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_message_id(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 95_794_000 picoseconds. - Weight::from_parts(89_931_979, 0) - // Standard Error: 371_349 - .saturating_add(Weight::from_parts(86_524_059, 0).saturating_mul(r.into())) + // Minimum execution time: 95_116_000 picoseconds. + Weight::from_parts(85_754_801, 0) + // Standard Error: 322_936 + .saturating_add(Weight::from_parts(85_646_040, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_program_id(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 97_924_000 picoseconds. - Weight::from_parts(84_041_201, 0) - // Standard Error: 327_841 - .saturating_add(Weight::from_parts(95_483_315, 0).saturating_mul(r.into())) + // Minimum execution time: 97_226_000 picoseconds. + Weight::from_parts(96_400_189, 0) + // Standard Error: 308_975 + .saturating_add(Weight::from_parts(84_400_658, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_source(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 97_122_000 picoseconds. - Weight::from_parts(86_789_268, 0) - // Standard Error: 353_259 - .saturating_add(Weight::from_parts(85_698_317, 0).saturating_mul(r.into())) + // Minimum execution time: 96_667_000 picoseconds. + Weight::from_parts(95_221_535, 0) + // Standard Error: 320_528 + .saturating_add(Weight::from_parts(85_320_330, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_value(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 94_821_000 picoseconds. - Weight::from_parts(92_694_130, 0) - // Standard Error: 340_146 - .saturating_add(Weight::from_parts(84_623_945, 0).saturating_mul(r.into())) + // Minimum execution time: 96_400_000 picoseconds. + Weight::from_parts(83_830_464, 0) + // Standard Error: 333_677 + .saturating_add(Weight::from_parts(86_153_462, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_value_available(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 93_840_000 picoseconds. - Weight::from_parts(87_888_572, 0) - // Standard Error: 369_465 - .saturating_add(Weight::from_parts(85_638_902, 0).saturating_mul(r.into())) + // Minimum execution time: 98_322_000 picoseconds. + Weight::from_parts(88_780_011, 0) + // Standard Error: 365_736 + .saturating_add(Weight::from_parts(86_373_607, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_gas_available(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 98_597_000 picoseconds. - Weight::from_parts(86_642_386, 0) - // Standard Error: 362_257 - .saturating_add(Weight::from_parts(85_598_887, 0).saturating_mul(r.into())) + // Minimum execution time: 94_234_000 picoseconds. + Weight::from_parts(93_394_916, 0) + // Standard Error: 310_495 + .saturating_add(Weight::from_parts(85_678_300, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_size(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 94_546_000 picoseconds. - Weight::from_parts(91_466_289, 0) - // Standard Error: 344_423 - .saturating_add(Weight::from_parts(84_318_848, 0).saturating_mul(r.into())) + // Minimum execution time: 95_316_000 picoseconds. + Weight::from_parts(88_012_950, 0) + // Standard Error: 309_598 + .saturating_add(Weight::from_parts(85_813_369, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_read(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 578_036_000 picoseconds. - Weight::from_parts(696_140_951, 0) - // Standard Error: 559_498 - .saturating_add(Weight::from_parts(149_397_501, 0).saturating_mul(r.into())) + // Minimum execution time: 715_150_000 picoseconds. + Weight::from_parts(769_593_524, 0) + // Standard Error: 493_525 + .saturating_add(Weight::from_parts(140_935_499, 0).saturating_mul(r.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_read_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 723_788_000 picoseconds. - Weight::from_parts(740_225_000, 0) - // Standard Error: 52_895 - .saturating_add(Weight::from_parts(13_188_120, 0).saturating_mul(n.into())) + // Minimum execution time: 844_162_000 picoseconds. + Weight::from_parts(851_053_000, 0) + // Standard Error: 50_294 + .saturating_add(Weight::from_parts(13_068_816, 0).saturating_mul(n.into())) } /// The range of component `r` is `[0, 20]`. fn gr_block_height(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 99_012_000 picoseconds. - Weight::from_parts(88_269_135, 0) - // Standard Error: 296_136 - .saturating_add(Weight::from_parts(92_296_104, 0).saturating_mul(r.into())) + // Minimum execution time: 94_243_000 picoseconds. + Weight::from_parts(87_583_955, 0) + // Standard Error: 343_578 + .saturating_add(Weight::from_parts(84_267_053, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_block_timestamp(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 93_803_000 picoseconds. - Weight::from_parts(87_097_769, 0) - // Standard Error: 367_325 - .saturating_add(Weight::from_parts(84_987_043, 0).saturating_mul(r.into())) + // Minimum execution time: 95_559_000 picoseconds. + Weight::from_parts(92_460_596, 0) + // Standard Error: 340_344 + .saturating_add(Weight::from_parts(85_006_110, 0).saturating_mul(r.into())) } /// The range of component `n` is `[0, 20]`. fn gr_random(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 96_663_000 picoseconds. - Weight::from_parts(105_357_427, 0) - // Standard Error: 366_135 - .saturating_add(Weight::from_parts(172_109_201, 0).saturating_mul(n.into())) + // Minimum execution time: 95_023_000 picoseconds. + Weight::from_parts(113_045_564, 0) + // Standard Error: 350_542 + .saturating_add(Weight::from_parts(169_289_972, 0).saturating_mul(n.into())) } /// The range of component `r` is `[0, 20]`. fn gr_reply_deposit(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 99_210_000 picoseconds. - Weight::from_parts(102_217_000, 0) - // Standard Error: 4_527_119 - .saturating_add(Weight::from_parts(845_784_967, 0).saturating_mul(r.into())) + // Minimum execution time: 95_407_000 picoseconds. + Weight::from_parts(99_094_000, 0) + // Standard Error: 3_585_438 + .saturating_add(Weight::from_parts(776_362_449, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_send(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 96_579_000 picoseconds. - Weight::from_parts(162_452_429, 0) - // Standard Error: 416_836 - .saturating_add(Weight::from_parts(257_900_517, 0).saturating_mul(r.into())) + // Minimum execution time: 96_709_000 picoseconds. + Weight::from_parts(153_262_764, 0) + // Standard Error: 391_637 + .saturating_add(Weight::from_parts(256_389_022, 0).saturating_mul(r.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_send_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 353_526_000 picoseconds. - Weight::from_parts(358_025_000, 0) - // Standard Error: 61_984 - .saturating_add(Weight::from_parts(21_521_461, 0).saturating_mul(n.into())) + // Minimum execution time: 341_633_000 picoseconds. + Weight::from_parts(345_693_000, 0) + // Standard Error: 61_029 + .saturating_add(Weight::from_parts(21_298_548, 0).saturating_mul(n.into())) } /// The range of component `r` is `[0, 20]`. fn gr_send_wgas(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 94_822_000 picoseconds. - Weight::from_parts(168_431_611, 0) - // Standard Error: 378_696 - .saturating_add(Weight::from_parts(263_135_958, 0).saturating_mul(r.into())) + // Minimum execution time: 97_817_000 picoseconds. + Weight::from_parts(172_033_153, 0) + // Standard Error: 412_230 + .saturating_add(Weight::from_parts(260_826_119, 0).saturating_mul(r.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_send_wgas_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 351_828_000 picoseconds. - Weight::from_parts(355_382_000, 0) - // Standard Error: 60_589 - .saturating_add(Weight::from_parts(21_325_400, 0).saturating_mul(n.into())) + // Minimum execution time: 353_433_000 picoseconds. + Weight::from_parts(359_185_000, 0) + // Standard Error: 60_153 + .saturating_add(Weight::from_parts(21_224_949, 0).saturating_mul(n.into())) } /// The range of component `r` is `[0, 20]`. fn gr_send_input(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 569_384_000 picoseconds. - Weight::from_parts(638_474_730, 0) - // Standard Error: 425_903 - .saturating_add(Weight::from_parts(275_691_711, 0).saturating_mul(r.into())) + // Minimum execution time: 716_180_000 picoseconds. + Weight::from_parts(782_890_839, 0) + // Standard Error: 547_225 + .saturating_add(Weight::from_parts(273_570_636, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_send_input_wgas(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 573_053_000 picoseconds. - Weight::from_parts(640_078_802, 0) - // Standard Error: 475_389 - .saturating_add(Weight::from_parts(284_337_155, 0).saturating_mul(r.into())) + // Minimum execution time: 719_827_000 picoseconds. + Weight::from_parts(805_763_844, 0) + // Standard Error: 503_245 + .saturating_add(Weight::from_parts(278_200_889, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_send_init(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 98_223_000 picoseconds. - Weight::from_parts(85_732_985, 0) - // Standard Error: 336_308 - .saturating_add(Weight::from_parts(92_936_006, 0).saturating_mul(r.into())) + // Minimum execution time: 96_518_000 picoseconds. + Weight::from_parts(82_218_173, 0) + // Standard Error: 358_867 + .saturating_add(Weight::from_parts(92_408_337, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_send_push(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_822_621_000 picoseconds. - Weight::from_parts(1_951_955_018, 0) - // Standard Error: 339_415 - .saturating_add(Weight::from_parts(157_557_756, 0).saturating_mul(r.into())) + // Minimum execution time: 1_829_368_000 picoseconds. + Weight::from_parts(1_976_758_302, 0) + // Standard Error: 349_703 + .saturating_add(Weight::from_parts(163_038_781, 0).saturating_mul(r.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_send_push_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 314_296_000 picoseconds. - Weight::from_parts(317_522_000, 0) - // Standard Error: 61_360 - .saturating_add(Weight::from_parts(29_499_741, 0).saturating_mul(n.into())) + // Minimum execution time: 315_829_000 picoseconds. + Weight::from_parts(318_464_000, 0) + // Standard Error: 54_637 + .saturating_add(Weight::from_parts(31_280_567, 0).saturating_mul(n.into())) } /// The range of component `r` is `[0, 20]`. fn gr_send_commit(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_835_106_000 picoseconds. - Weight::from_parts(1_948_516_646, 0) - // Standard Error: 382_008 - .saturating_add(Weight::from_parts(214_812_508, 0).saturating_mul(r.into())) + // Minimum execution time: 1_818_937_000 picoseconds. + Weight::from_parts(1_941_969_566, 0) + // Standard Error: 412_244 + .saturating_add(Weight::from_parts(220_650_756, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_send_commit_wgas(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_827_496_000 picoseconds. - Weight::from_parts(1_949_190_773, 0) - // Standard Error: 340_175 - .saturating_add(Weight::from_parts(218_001_536, 0).saturating_mul(r.into())) + // Minimum execution time: 1_815_762_000 picoseconds. + Weight::from_parts(1_958_182_203, 0) + // Standard Error: 374_381 + .saturating_add(Weight::from_parts(229_106_637, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_reservation_send(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 264_306_000 picoseconds. - Weight::from_parts(363_536_651, 0) - // Standard Error: 467_914 - .saturating_add(Weight::from_parts(265_564_072, 0).saturating_mul(r.into())) + // Minimum execution time: 259_040_000 picoseconds. + Weight::from_parts(345_586_401, 0) + // Standard Error: 402_258 + .saturating_add(Weight::from_parts(274_866_021, 0).saturating_mul(r.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_reservation_send_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 523_150_000 picoseconds. - Weight::from_parts(535_842_000, 0) - // Standard Error: 65_412 - .saturating_add(Weight::from_parts(21_698_063, 0).saturating_mul(n.into())) + // Minimum execution time: 523_014_000 picoseconds. + Weight::from_parts(525_681_000, 0) + // Standard Error: 56_470 + .saturating_add(Weight::from_parts(21_443_571, 0).saturating_mul(n.into())) } /// The range of component `r` is `[0, 20]`. fn gr_reservation_send_commit(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_974_743_000 picoseconds. - Weight::from_parts(2_096_494_995, 0) - // Standard Error: 474_778 - .saturating_add(Weight::from_parts(232_524_299, 0).saturating_mul(r.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_reply(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 94_139_000 picoseconds. - Weight::from_parts(101_775_569, 0) - // Standard Error: 452_439 - .saturating_add(Weight::from_parts(16_839_430, 0).saturating_mul(r.into())) + // Minimum execution time: 1_967_181_000 picoseconds. + Weight::from_parts(2_076_078_781, 0) + // Standard Error: 455_370 + .saturating_add(Weight::from_parts(246_494_683, 0).saturating_mul(r.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_reply_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 112_050_000 picoseconds. - Weight::from_parts(102_205_366, 0) - // Standard Error: 1_008 - .saturating_add(Weight::from_parts(431_304, 0).saturating_mul(n.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_reply_wgas(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 93_528_000 picoseconds. - Weight::from_parts(99_748_422, 0) - // Standard Error: 396_992 - .saturating_add(Weight::from_parts(20_536_877, 0).saturating_mul(r.into())) + // Minimum execution time: 114_790_000 picoseconds. + Weight::from_parts(106_908_278, 0) + // Standard Error: 1_274 + .saturating_add(Weight::from_parts(430_785, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_reply_wgas_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 117_832_000 picoseconds. - Weight::from_parts(104_552_847, 0) - // Standard Error: 1_402 - .saturating_add(Weight::from_parts(432_018, 0).saturating_mul(n.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_reply_commit(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 93_325_000 picoseconds. - Weight::from_parts(101_074_097, 0) - // Standard Error: 454_790 - .saturating_add(Weight::from_parts(20_838_102, 0).saturating_mul(r.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_reply_commit_wgas(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 93_800_000 picoseconds. - Weight::from_parts(102_249_326, 0) - // Standard Error: 463_488 - .saturating_add(Weight::from_parts(15_991_473, 0).saturating_mul(r.into())) + // Minimum execution time: 115_541_000 picoseconds. + Weight::from_parts(101_956_035, 0) + // Standard Error: 3_603 + .saturating_add(Weight::from_parts(442_387, 0).saturating_mul(n.into())) } /// The range of component `r` is `[0, 20]`. fn gr_reply_push(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 93_153_000 picoseconds. - Weight::from_parts(121_452_989, 0) - // Standard Error: 390_540 - .saturating_add(Weight::from_parts(145_641_178, 0).saturating_mul(r.into())) + // Minimum execution time: 94_082_000 picoseconds. + Weight::from_parts(138_243_307, 0) + // Standard Error: 409_163 + .saturating_add(Weight::from_parts(154_758_505, 0).saturating_mul(r.into())) } /// The range of component `n` is `[0, 8192]`. fn gr_reply_push_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 115_529_000 picoseconds. - Weight::from_parts(120_413_000, 0) - // Standard Error: 3_105 - .saturating_add(Weight::from_parts(640_863, 0).saturating_mul(n.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_reply_input(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 566_859_000 picoseconds. - Weight::from_parts(631_111_316, 0) - // Standard Error: 7_012_228 - .saturating_add(Weight::from_parts(21_896_983, 0).saturating_mul(r.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_reply_input_wgas(_r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 565_382_000 picoseconds. - Weight::from_parts(613_048_008, 0) - } - /// The range of component `r` is `[0, 1]`. - fn gr_reservation_reply(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 104_401_000 picoseconds. - Weight::from_parts(112_651_320, 0) - // Standard Error: 438_590 - .saturating_add(Weight::from_parts(11_095_379, 0).saturating_mul(r.into())) + // Minimum execution time: 111_536_000 picoseconds. + Weight::from_parts(114_497_000, 0) + // Standard Error: 2_599 + .saturating_add(Weight::from_parts(656_994, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_reservation_reply_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 115_615_000 picoseconds. - Weight::from_parts(112_987_750, 0) - // Standard Error: 960 - .saturating_add(Weight::from_parts(423_774, 0).saturating_mul(n.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_reservation_reply_commit(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 105_056_000 picoseconds. - Weight::from_parts(113_735_922, 0) - // Standard Error: 466_586 - .saturating_add(Weight::from_parts(5_305_577, 0).saturating_mul(r.into())) + // Minimum execution time: 114_322_000 picoseconds. + Weight::from_parts(113_131_028, 0) + // Standard Error: 3_727 + .saturating_add(Weight::from_parts(436_168, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_reservation_reply_commit_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 113_897_000 picoseconds. - Weight::from_parts(112_616_408, 0) - // Standard Error: 1_722 - .saturating_add(Weight::from_parts(428_420, 0).saturating_mul(n.into())) + // Minimum execution time: 117_751_000 picoseconds. + Weight::from_parts(161_418_174, 0) + // Standard Error: 6_635 + .saturating_add(Weight::from_parts(405_229, 0).saturating_mul(n.into())) } /// The range of component `r` is `[0, 20]`. fn gr_reply_to(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 93_845_000 picoseconds. - Weight::from_parts(97_247_314, 0) - // Standard Error: 366_814 - .saturating_add(Weight::from_parts(85_900_587, 0).saturating_mul(r.into())) + // Minimum execution time: 93_524_000 picoseconds. + Weight::from_parts(89_332_032, 0) + // Standard Error: 294_566 + .saturating_add(Weight::from_parts(86_798_759, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_signal_code(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 98_960_000 picoseconds. - Weight::from_parts(96_741_705, 0) - // Standard Error: 331_442 - .saturating_add(Weight::from_parts(82_371_743, 0).saturating_mul(r.into())) + // Minimum execution time: 95_216_000 picoseconds. + Weight::from_parts(83_424_786, 0) + // Standard Error: 316_301 + .saturating_add(Weight::from_parts(84_774_296, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_signal_from(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 95_150_000 picoseconds. - Weight::from_parts(94_807_000, 0) - // Standard Error: 308_494 - .saturating_add(Weight::from_parts(85_723_479, 0).saturating_mul(r.into())) + // Minimum execution time: 96_461_000 picoseconds. + Weight::from_parts(97_636_300, 0) + // Standard Error: 278_297 + .saturating_add(Weight::from_parts(86_743_159, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_reply_push_input(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 565_388_000 picoseconds. - Weight::from_parts(606_358_854, 0) - // Standard Error: 430_766 - .saturating_add(Weight::from_parts(108_769_267, 0).saturating_mul(r.into())) + // Minimum execution time: 724_902_000 picoseconds. + Weight::from_parts(784_128_285, 0) + // Standard Error: 444_406 + .saturating_add(Weight::from_parts(105_223_470, 0).saturating_mul(r.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_reply_push_input_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 591_660_000 picoseconds. - Weight::from_parts(597_035_528, 0) - // Standard Error: 2_641 - .saturating_add(Weight::from_parts(153_781, 0).saturating_mul(n.into())) + // Minimum execution time: 737_666_000 picoseconds. + Weight::from_parts(758_797_216, 0) + // Standard Error: 1_260 + .saturating_add(Weight::from_parts(154_837, 0).saturating_mul(n.into())) } /// The range of component `r` is `[0, 20]`. fn gr_send_push_input(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_317_147_000 picoseconds. - Weight::from_parts(2_514_940_964, 0) - // Standard Error: 546_319 - .saturating_add(Weight::from_parts(128_825_542, 0).saturating_mul(r.into())) + // Minimum execution time: 2_498_871_000 picoseconds. + Weight::from_parts(2_688_516_696, 0) + // Standard Error: 531_545 + .saturating_add(Weight::from_parts(131_060_314, 0).saturating_mul(r.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_send_push_input_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_560_344_000 picoseconds. - Weight::from_parts(2_512_409_449, 0) - // Standard Error: 15_466 - .saturating_add(Weight::from_parts(12_395_144, 0).saturating_mul(n.into())) + // Minimum execution time: 2_657_855_000 picoseconds. + Weight::from_parts(2_746_003_287, 0) + // Standard Error: 12_743 + .saturating_add(Weight::from_parts(13_716_214, 0).saturating_mul(n.into())) } /// The range of component `r` is `[0, 20]`. fn gr_debug(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 97_996_000 picoseconds. - Weight::from_parts(130_630_238, 0) - // Standard Error: 414_418 - .saturating_add(Weight::from_parts(114_735_577, 0).saturating_mul(r.into())) + // Minimum execution time: 96_990_000 picoseconds. + Weight::from_parts(110_812_744, 0) + // Standard Error: 347_035 + .saturating_add(Weight::from_parts(120_462_128, 0).saturating_mul(r.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_debug_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 157_513_000 picoseconds. - Weight::from_parts(160_584_000, 0) - // Standard Error: 57_227 - .saturating_add(Weight::from_parts(25_738_939, 0).saturating_mul(n.into())) + // Minimum execution time: 170_244_000 picoseconds. + Weight::from_parts(175_502_000, 0) + // Standard Error: 56_203 + .saturating_add(Weight::from_parts(25_870_902, 0).saturating_mul(n.into())) } /// The range of component `r` is `[0, 20]`. fn gr_reply_code(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 92_652_000 picoseconds. - Weight::from_parts(88_138_429, 0) - // Standard Error: 330_537 - .saturating_add(Weight::from_parts(83_235_234, 0).saturating_mul(r.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_exit(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 93_824_000 picoseconds. - Weight::from_parts(102_740_497, 0) - // Standard Error: 428_593 - .saturating_add(Weight::from_parts(23_682_102, 0).saturating_mul(r.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_leave(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 92_530_000 picoseconds. - Weight::from_parts(101_410_861, 0) - // Standard Error: 432_236 - .saturating_add(Weight::from_parts(12_196_938, 0).saturating_mul(r.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_wait(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 93_402_000 picoseconds. - Weight::from_parts(102_285_877, 0) - // Standard Error: 466_463 - .saturating_add(Weight::from_parts(13_156_522, 0).saturating_mul(r.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_wait_for(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 95_706_000 picoseconds. - Weight::from_parts(102_513_059, 0) - // Standard Error: 464_787 - .saturating_add(Weight::from_parts(13_986_540, 0).saturating_mul(r.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_wait_up_to(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 93_057_000 picoseconds. - Weight::from_parts(99_083_869, 0) - // Standard Error: 378_747 - .saturating_add(Weight::from_parts(12_230_330, 0).saturating_mul(r.into())) + // Minimum execution time: 97_676_000 picoseconds. + Weight::from_parts(91_226_383, 0) + // Standard Error: 320_296 + .saturating_add(Weight::from_parts(82_761_490, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_wake(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 177_947_000 picoseconds. - Weight::from_parts(226_692_243, 0) - // Standard Error: 265_725 - .saturating_add(Weight::from_parts(156_938_838, 0).saturating_mul(r.into())) + // Minimum execution time: 149_319_000 picoseconds. + Weight::from_parts(230_971_562, 0) + // Standard Error: 338_138 + .saturating_add(Weight::from_parts(157_262_608, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_create_program(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 107_346_000 picoseconds. - Weight::from_parts(160_631_540, 0) - // Standard Error: 352_753 - .saturating_add(Weight::from_parts(338_685_448, 0).saturating_mul(r.into())) + // Minimum execution time: 108_167_000 picoseconds. + Weight::from_parts(178_994_489, 0) + // Standard Error: 404_012 + .saturating_add(Weight::from_parts(348_487_075, 0).saturating_mul(r.into())) } /// The range of component `p` is `[0, 2048]`. /// The range of component `s` is `[1, 2048]`. @@ -3040,22 +3044,22 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 44_754_074_000 picoseconds. - Weight::from_parts(44_833_050_000, 0) - // Standard Error: 269_308 - .saturating_add(Weight::from_parts(7_629_892, 0).saturating_mul(p.into())) - // Standard Error: 269_294 - .saturating_add(Weight::from_parts(179_148_245, 0).saturating_mul(s.into())) + // Minimum execution time: 43_645_119_000 picoseconds. + Weight::from_parts(43_811_648_000, 0) + // Standard Error: 262_276 + .saturating_add(Weight::from_parts(7_776_587, 0).saturating_mul(p.into())) + // Standard Error: 262_263 + .saturating_add(Weight::from_parts(178_958_075, 0).saturating_mul(s.into())) } /// The range of component `r` is `[0, 20]`. fn gr_create_program_wgas(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 108_278_000 picoseconds. - Weight::from_parts(161_208_126, 0) - // Standard Error: 368_644 - .saturating_add(Weight::from_parts(346_324_329, 0).saturating_mul(r.into())) + // Minimum execution time: 104_639_000 picoseconds. + Weight::from_parts(169_517_206, 0) + // Standard Error: 363_225 + .saturating_add(Weight::from_parts(357_078_703, 0).saturating_mul(r.into())) } /// The range of component `p` is `[0, 2048]`. /// The range of component `s` is `[1, 2048]`. @@ -3063,32 +3067,32 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 44_266_209_000 picoseconds. - Weight::from_parts(44_559_345_000, 0) - // Standard Error: 270_420 - .saturating_add(Weight::from_parts(7_460_172, 0).saturating_mul(p.into())) - // Standard Error: 270_407 - .saturating_add(Weight::from_parts(179_211_260, 0).saturating_mul(s.into())) + // Minimum execution time: 46_491_851_000 picoseconds. + Weight::from_parts(46_603_783_000, 0) + // Standard Error: 280_431 + .saturating_add(Weight::from_parts(7_250_257, 0).saturating_mul(p.into())) + // Standard Error: 280_417 + .saturating_add(Weight::from_parts(177_722_888, 0).saturating_mul(s.into())) } /// The range of component `r` is `[0, 20]`. fn gr_pay_program_rent(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 94_889_000 picoseconds. - Weight::from_parts(115_310_524, 0) - // Standard Error: 34_049 - .saturating_add(Weight::from_parts(1_916_607, 0).saturating_mul(r.into())) + // Minimum execution time: 95_721_000 picoseconds. + Weight::from_parts(114_995_832, 0) + // Standard Error: 36_809 + .saturating_add(Weight::from_parts(1_873_016, 0).saturating_mul(r.into())) } /// The range of component `p` is `[0, 512]`. fn lazy_pages_signal_read(p: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `141` // Estimated: `1131 + p * (9900 ±0)` - // Minimum execution time: 97_825_000 picoseconds. - Weight::from_parts(251_440_245, 1131) - // Standard Error: 70_641 - .saturating_add(Weight::from_parts(15_652_952, 0).saturating_mul(p.into())) + // Minimum execution time: 97_655_000 picoseconds. + Weight::from_parts(138_058_498, 1131) + // Standard Error: 18_813 + .saturating_add(Weight::from_parts(16_311_194, 0).saturating_mul(p.into())) .saturating_add(RocksDbWeight::get().reads((4_u64).saturating_mul(p.into()))) .saturating_add(Weight::from_parts(0, 9900).saturating_mul(p.into())) } @@ -3097,10 +3101,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `141` // Estimated: `1131 + p * (9900 ±0)` - // Minimum execution time: 96_761_000 picoseconds. - Weight::from_parts(100_398_000, 1131) - // Standard Error: 45_532 - .saturating_add(Weight::from_parts(39_790_625, 0).saturating_mul(p.into())) + // Minimum execution time: 96_083_000 picoseconds. + Weight::from_parts(98_597_000, 1131) + // Standard Error: 43_515 + .saturating_add(Weight::from_parts(42_632_421, 0).saturating_mul(p.into())) .saturating_add(RocksDbWeight::get().reads((4_u64).saturating_mul(p.into()))) .saturating_add(Weight::from_parts(0, 9900).saturating_mul(p.into())) } @@ -3109,10 +3113,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `141` // Estimated: `5069931` - // Minimum execution time: 7_471_807_000 picoseconds. - Weight::from_parts(7_440_591_962, 5069931) - // Standard Error: 168_373 - .saturating_add(Weight::from_parts(40_244_359, 0).saturating_mul(p.into())) + // Minimum execution time: 8_196_422_000 picoseconds. + Weight::from_parts(8_474_214_520, 5069931) + // Standard Error: 71_564 + .saturating_add(Weight::from_parts(41_738_666, 0).saturating_mul(p.into())) .saturating_add(RocksDbWeight::get().reads(2048_u64)) } /// The range of component `p` is `[0, 512]`. @@ -3120,10 +3124,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `1813 + p * (65580 ±0)` // Estimated: `1939 + p * (75482 ±0)` - // Minimum execution time: 97_303_000 picoseconds. - Weight::from_parts(98_185_000, 1939) - // Standard Error: 38_471 - .saturating_add(Weight::from_parts(55_016_921, 0).saturating_mul(p.into())) + // Minimum execution time: 93_446_000 picoseconds. + Weight::from_parts(96_664_000, 1939) + // Standard Error: 46_722 + .saturating_add(Weight::from_parts(55_567_620, 0).saturating_mul(p.into())) .saturating_add(RocksDbWeight::get().reads((4_u64).saturating_mul(p.into()))) .saturating_add(Weight::from_parts(0, 75482).saturating_mul(p.into())) } @@ -3132,10 +3136,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `141` // Estimated: `1131 + p * (9900 ±0)` - // Minimum execution time: 102_497_000 picoseconds. - Weight::from_parts(104_932_685, 1131) - // Standard Error: 78_974 - .saturating_add(Weight::from_parts(39_257_150, 0).saturating_mul(p.into())) + // Minimum execution time: 106_137_000 picoseconds. + Weight::from_parts(107_751_954, 1131) + // Standard Error: 71_200 + .saturating_add(Weight::from_parts(41_236_505, 0).saturating_mul(p.into())) .saturating_add(RocksDbWeight::get().reads((4_u64).saturating_mul(p.into()))) .saturating_add(Weight::from_parts(0, 9900).saturating_mul(p.into())) } @@ -3144,10 +3148,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `141` // Estimated: `1496 + p * (9883 ±2)` - // Minimum execution time: 612_308_000 picoseconds. - Weight::from_parts(642_079_999, 1496) - // Standard Error: 357_245 - .saturating_add(Weight::from_parts(46_518_860, 0).saturating_mul(p.into())) + // Minimum execution time: 758_237_000 picoseconds. + Weight::from_parts(760_351_083, 1496) + // Standard Error: 319_479 + .saturating_add(Weight::from_parts(53_277_303, 0).saturating_mul(p.into())) .saturating_add(RocksDbWeight::get().reads((4_u64).saturating_mul(p.into()))) .saturating_add(Weight::from_parts(0, 9883).saturating_mul(p.into())) } @@ -3156,10 +3160,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `141` // Estimated: `317931` - // Minimum execution time: 1_068_248_000 picoseconds. - Weight::from_parts(1_080_741_205, 317931) - // Standard Error: 262_216 - .saturating_add(Weight::from_parts(50_047_907, 0).saturating_mul(p.into())) + // Minimum execution time: 1_299_071_000 picoseconds. + Weight::from_parts(1_320_542_278, 317931) + // Standard Error: 364_770 + .saturating_add(Weight::from_parts(53_225_083, 0).saturating_mul(p.into())) .saturating_add(RocksDbWeight::get().reads(128_u64)) } /// The range of component `r` is `[0, 20]`. @@ -3167,303 +3171,303 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 3_099_000 picoseconds. - Weight::from_parts(6_340_084, 0) - // Standard Error: 180_257 - .saturating_add(Weight::from_parts(74_666_091, 0).saturating_mul(r.into())) + // Minimum execution time: 4_118_000 picoseconds. + Weight::from_parts(7_418_987, 0) + // Standard Error: 299_976 + .saturating_add(Weight::from_parts(77_036_564, 0).saturating_mul(r.into())) } /// The range of component `r` is `[50, 500]`. fn instr_i64load(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 4_391_547_000 picoseconds. - Weight::from_parts(4_140_785_425, 0) - // Standard Error: 89_369 - .saturating_add(Weight::from_parts(5_769_622, 0).saturating_mul(r.into())) + // Minimum execution time: 4_461_228_000 picoseconds. + Weight::from_parts(4_172_544_233, 0) + // Standard Error: 108_717 + .saturating_add(Weight::from_parts(5_492_504, 0).saturating_mul(r.into())) } /// The range of component `r` is `[50, 500]`. fn instr_i32load(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 4_386_802_000 picoseconds. - Weight::from_parts(4_243_536_456, 0) - // Standard Error: 95_210 - .saturating_add(Weight::from_parts(5_278_131, 0).saturating_mul(r.into())) + // Minimum execution time: 4_440_105_000 picoseconds. + Weight::from_parts(4_189_326_223, 0) + // Standard Error: 94_884 + .saturating_add(Weight::from_parts(5_283_060, 0).saturating_mul(r.into())) } /// The range of component `r` is `[50, 500]`. fn instr_i64store(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 11_072_272_000 picoseconds. - Weight::from_parts(11_558_306_225, 0) - // Standard Error: 165_659 - .saturating_add(Weight::from_parts(9_828_260, 0).saturating_mul(r.into())) + // Minimum execution time: 11_389_557_000 picoseconds. + Weight::from_parts(11_860_510_711, 0) + // Standard Error: 156_021 + .saturating_add(Weight::from_parts(9_199_358, 0).saturating_mul(r.into())) } /// The range of component `r` is `[50, 500]`. fn instr_i32store(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 10_285_071_000 picoseconds. - Weight::from_parts(11_137_621_942, 0) - // Standard Error: 147_513 - .saturating_add(Weight::from_parts(9_014_757, 0).saturating_mul(r.into())) + // Minimum execution time: 11_497_103_000 picoseconds. + Weight::from_parts(11_330_880_436, 0) + // Standard Error: 132_247 + .saturating_add(Weight::from_parts(10_016_516, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_select(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_285_000 picoseconds. - Weight::from_parts(2_410_000, 0) - // Standard Error: 7_624 - .saturating_add(Weight::from_parts(3_864_490, 0).saturating_mul(r.into())) + // Minimum execution time: 2_381_000 picoseconds. + Weight::from_parts(2_444_000, 0) + // Standard Error: 7_402 + .saturating_add(Weight::from_parts(3_876_295, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_if(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_342_000 picoseconds. - Weight::from_parts(2_433_000, 0) - // Standard Error: 6_413 - .saturating_add(Weight::from_parts(3_120_732, 0).saturating_mul(r.into())) + // Minimum execution time: 2_405_000 picoseconds. + Weight::from_parts(481_308, 0) + // Standard Error: 8_161 + .saturating_add(Weight::from_parts(3_159_957, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_br(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_301_000 picoseconds. - Weight::from_parts(3_591_730, 0) - // Standard Error: 1_106 - .saturating_add(Weight::from_parts(1_565_415, 0).saturating_mul(r.into())) + // Minimum execution time: 2_371_000 picoseconds. + Weight::from_parts(3_249_787, 0) + // Standard Error: 1_586 + .saturating_add(Weight::from_parts(1_582_965, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_br_if(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_306_000 picoseconds. - Weight::from_parts(2_461_000, 0) - // Standard Error: 7_711 - .saturating_add(Weight::from_parts(2_932_880, 0).saturating_mul(r.into())) + // Minimum execution time: 2_216_000 picoseconds. + Weight::from_parts(2_300_000, 0) + // Standard Error: 6_757 + .saturating_add(Weight::from_parts(2_971_649, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_br_table(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_358_000 picoseconds. - Weight::from_parts(2_144_801, 0) - // Standard Error: 22_082 - .saturating_add(Weight::from_parts(5_266_139, 0).saturating_mul(r.into())) + // Minimum execution time: 2_259_000 picoseconds. + Weight::from_parts(2_872_259, 0) + // Standard Error: 19_834 + .saturating_add(Weight::from_parts(5_176_111, 0).saturating_mul(r.into())) } /// The range of component `e` is `[1, 256]`. fn instr_br_table_per_entry(e: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 6_803_000 picoseconds. - Weight::from_parts(5_374_690, 0) - // Standard Error: 1_699 - .saturating_add(Weight::from_parts(171_193, 0).saturating_mul(e.into())) + // Minimum execution time: 6_999_000 picoseconds. + Weight::from_parts(6_015_140, 0) + // Standard Error: 1_903 + .saturating_add(Weight::from_parts(170_143, 0).saturating_mul(e.into())) } /// The range of component `r` is `[0, 50]`. fn instr_call_const(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_431_000 picoseconds. - Weight::from_parts(4_875_813, 0) - // Standard Error: 8_258 - .saturating_add(Weight::from_parts(2_629_733, 0).saturating_mul(r.into())) + // Minimum execution time: 2_308_000 picoseconds. + Weight::from_parts(5_881_148, 0) + // Standard Error: 9_069 + .saturating_add(Weight::from_parts(2_574_099, 0).saturating_mul(r.into())) } fn instr_i64const(r: u32, ) -> Weight { Weight::from_parts(0, 0) - .saturating_add(Weight::from_parts(2_629_733 - - 2_421_700, 0).saturating_mul(r.into())) + .saturating_add(Weight::from_parts(2_574_099 - + 2_423_093, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_call(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_403_000 picoseconds. - Weight::from_parts(5_140_243, 0) - // Standard Error: 13_164 - .saturating_add(Weight::from_parts(2_421_700, 0).saturating_mul(r.into())) + // Minimum execution time: 2_337_000 picoseconds. + Weight::from_parts(5_123_036, 0) + // Standard Error: 12_143 + .saturating_add(Weight::from_parts(2_423_093, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_call_indirect(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_669_000 picoseconds. - Weight::from_parts(22_369_265, 0) - // Standard Error: 28_577 - .saturating_add(Weight::from_parts(9_740_558, 0).saturating_mul(r.into())) + // Minimum execution time: 2_736_000 picoseconds. + Weight::from_parts(16_600_828, 0) + // Standard Error: 30_025 + .saturating_add(Weight::from_parts(10_214_913, 0).saturating_mul(r.into())) } /// The range of component `p` is `[0, 128]`. fn instr_call_indirect_per_param(p: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 12_277_000 picoseconds. - Weight::from_parts(3_596_853, 0) - // Standard Error: 5_869 - .saturating_add(Weight::from_parts(1_258_605, 0).saturating_mul(p.into())) + // Minimum execution time: 12_483_000 picoseconds. + Weight::from_parts(1_416_669, 0) + // Standard Error: 5_995 + .saturating_add(Weight::from_parts(1_336_453, 0).saturating_mul(p.into())) } /// The range of component `l` is `[0, 1024]`. fn instr_call_per_local(_l: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 5_391_000 picoseconds. - Weight::from_parts(5_778_137, 0) + // Minimum execution time: 5_497_000 picoseconds. + Weight::from_parts(5_981_231, 0) } /// The range of component `r` is `[0, 50]`. fn instr_local_get(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 4_835_000 picoseconds. - Weight::from_parts(6_065_483, 0) - // Standard Error: 3_006 - .saturating_add(Weight::from_parts(378_512, 0).saturating_mul(r.into())) + // Minimum execution time: 4_730_000 picoseconds. + Weight::from_parts(5_851_529, 0) + // Standard Error: 2_642 + .saturating_add(Weight::from_parts(392_869, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_local_set(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 4_722_000 picoseconds. - Weight::from_parts(3_902_309, 0) - // Standard Error: 5_742 - .saturating_add(Weight::from_parts(1_056_408, 0).saturating_mul(r.into())) + // Minimum execution time: 4_837_000 picoseconds. + Weight::from_parts(4_473_635, 0) + // Standard Error: 5_210 + .saturating_add(Weight::from_parts(1_003_312, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_local_tee(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 4_888_000 picoseconds. - Weight::from_parts(4_512_058, 0) - // Standard Error: 6_410 - .saturating_add(Weight::from_parts(1_001_510, 0).saturating_mul(r.into())) + // Minimum execution time: 4_802_000 picoseconds. + Weight::from_parts(2_153_776, 0) + // Standard Error: 11_517 + .saturating_add(Weight::from_parts(1_186_032, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_global_get(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 6_413_000 picoseconds. - Weight::from_parts(2_704_134, 0) - // Standard Error: 7_244 - .saturating_add(Weight::from_parts(804_200, 0).saturating_mul(r.into())) + // Minimum execution time: 6_375_000 picoseconds. + Weight::from_parts(3_754_449, 0) + // Standard Error: 5_686 + .saturating_add(Weight::from_parts(763_597, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_global_set(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 6_516_000 picoseconds. - Weight::from_parts(1_028_752, 0) - // Standard Error: 8_792 - .saturating_add(Weight::from_parts(1_494_630, 0).saturating_mul(r.into())) + // Minimum execution time: 6_475_000 picoseconds. + Weight::from_parts(266_670, 0) + // Standard Error: 10_193 + .saturating_add(Weight::from_parts(1_552_777, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_memory_current(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 5_560_000 picoseconds. - Weight::from_parts(1_126_442, 0) - // Standard Error: 14_476 - .saturating_add(Weight::from_parts(7_240_597, 0).saturating_mul(r.into())) + // Minimum execution time: 6_887_000 picoseconds. + Weight::from_parts(4_333_544, 0) + // Standard Error: 10_173 + .saturating_add(Weight::from_parts(6_952_830, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64clz(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_299_000 picoseconds. - Weight::from_parts(2_449_000, 0) - // Standard Error: 7_416 - .saturating_add(Weight::from_parts(3_344_387, 0).saturating_mul(r.into())) + // Minimum execution time: 2_267_000 picoseconds. + Weight::from_parts(2_351_000, 0) + // Standard Error: 5_280 + .saturating_add(Weight::from_parts(3_360_413, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32clz(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_389_000 picoseconds. - Weight::from_parts(2_551_000, 0) - // Standard Error: 5_708 - .saturating_add(Weight::from_parts(3_133_430, 0).saturating_mul(r.into())) + // Minimum execution time: 2_283_000 picoseconds. + Weight::from_parts(2_357_000, 0) + // Standard Error: 4_452 + .saturating_add(Weight::from_parts(3_099_489, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64ctz(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_428_000 picoseconds. - Weight::from_parts(2_511_000, 0) - // Standard Error: 7_262 - .saturating_add(Weight::from_parts(3_192_675, 0).saturating_mul(r.into())) + // Minimum execution time: 2_328_000 picoseconds. + Weight::from_parts(2_417_000, 0) + // Standard Error: 5_054 + .saturating_add(Weight::from_parts(3_106_996, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32ctz(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_333_000 picoseconds. - Weight::from_parts(2_426_000, 0) - // Standard Error: 4_554 - .saturating_add(Weight::from_parts(2_683_293, 0).saturating_mul(r.into())) + // Minimum execution time: 2_230_000 picoseconds. + Weight::from_parts(2_296_000, 0) + // Standard Error: 3_924 + .saturating_add(Weight::from_parts(2_681_831, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64popcnt(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_334_000 picoseconds. - Weight::from_parts(2_385_000, 0) - // Standard Error: 4_686 - .saturating_add(Weight::from_parts(631_609, 0).saturating_mul(r.into())) + // Minimum execution time: 2_294_000 picoseconds. + Weight::from_parts(2_438_000, 0) + // Standard Error: 4_198 + .saturating_add(Weight::from_parts(603_106, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32popcnt(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_356_000 picoseconds. - Weight::from_parts(1_221_890, 0) - // Standard Error: 3_960 - .saturating_add(Weight::from_parts(452_047, 0).saturating_mul(r.into())) + // Minimum execution time: 2_257_000 picoseconds. + Weight::from_parts(2_121_941, 0) + // Standard Error: 3_525 + .saturating_add(Weight::from_parts(401_578, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64eqz(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_318_000 picoseconds. - Weight::from_parts(2_390_000, 0) - // Standard Error: 11_114 - .saturating_add(Weight::from_parts(1_916_122, 0).saturating_mul(r.into())) + // Minimum execution time: 2_224_000 picoseconds. + Weight::from_parts(2_291_000, 0) + // Standard Error: 9_436 + .saturating_add(Weight::from_parts(1_891_725, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32eqz(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_436_000 picoseconds. - Weight::from_parts(2_504_000, 0) - // Standard Error: 7_104 - .saturating_add(Weight::from_parts(1_156_958, 0).saturating_mul(r.into())) + // Minimum execution time: 2_273_000 picoseconds. + Weight::from_parts(2_417_000, 0) + // Standard Error: 8_255 + .saturating_add(Weight::from_parts(1_289_311, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32extend8s(r: u32, ) -> Weight { @@ -3471,631 +3475,631 @@ impl WeightInfo for () { // Measured: `0` // Estimated: `0` // Minimum execution time: 2_276_000 picoseconds. - Weight::from_parts(1_708_596, 0) - // Standard Error: 2_843 - .saturating_add(Weight::from_parts(377_083, 0).saturating_mul(r.into())) + Weight::from_parts(1_306_236, 0) + // Standard Error: 5_275 + .saturating_add(Weight::from_parts(426_430, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32extend16s(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_386_000 picoseconds. - Weight::from_parts(1_424_415, 0) - // Standard Error: 3_599 - .saturating_add(Weight::from_parts(395_934, 0).saturating_mul(r.into())) + // Minimum execution time: 2_341_000 picoseconds. + Weight::from_parts(1_669_540, 0) + // Standard Error: 4_902 + .saturating_add(Weight::from_parts(405_099, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64extend8s(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_396_000 picoseconds. - Weight::from_parts(2_491_000, 0) - // Standard Error: 3_774 - .saturating_add(Weight::from_parts(516_281, 0).saturating_mul(r.into())) + // Minimum execution time: 2_244_000 picoseconds. + Weight::from_parts(2_317_000, 0) + // Standard Error: 3_916 + .saturating_add(Weight::from_parts(552_354, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64extend16s(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_308_000 picoseconds. - Weight::from_parts(548_192, 0) - // Standard Error: 4_583 - .saturating_add(Weight::from_parts(556_734, 0).saturating_mul(r.into())) + // Minimum execution time: 2_316_000 picoseconds. + Weight::from_parts(2_395_000, 0) + // Standard Error: 5_375 + .saturating_add(Weight::from_parts(589_608, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64extend32s(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_333_000 picoseconds. - Weight::from_parts(447_271, 0) - // Standard Error: 5_300 - .saturating_add(Weight::from_parts(535_915, 0).saturating_mul(r.into())) + // Minimum execution time: 2_258_000 picoseconds. + Weight::from_parts(98_911, 0) + // Standard Error: 7_257 + .saturating_add(Weight::from_parts(581_834, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64extendsi32(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_340_000 picoseconds. - Weight::from_parts(1_639_695, 0) - // Standard Error: 3_519 - .saturating_add(Weight::from_parts(368_523, 0).saturating_mul(r.into())) + // Minimum execution time: 2_293_000 picoseconds. + Weight::from_parts(1_730_402, 0) + // Standard Error: 4_194 + .saturating_add(Weight::from_parts(357_287, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64extendui32(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_305_000 picoseconds. - Weight::from_parts(2_843_474, 0) - // Standard Error: 1_950 - .saturating_add(Weight::from_parts(176_592, 0).saturating_mul(r.into())) + // Minimum execution time: 2_580_000 picoseconds. + Weight::from_parts(2_927_247, 0) + // Standard Error: 2_012 + .saturating_add(Weight::from_parts(181_106, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32wrapi64(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_351_000 picoseconds. - Weight::from_parts(2_894_613, 0) - // Standard Error: 2_024 - .saturating_add(Weight::from_parts(188_853, 0).saturating_mul(r.into())) + // Minimum execution time: 2_308_000 picoseconds. + Weight::from_parts(2_742_236, 0) + // Standard Error: 2_482 + .saturating_add(Weight::from_parts(187_830, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64eq(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_353_000 picoseconds. - Weight::from_parts(2_418_000, 0) - // Standard Error: 9_504 - .saturating_add(Weight::from_parts(1_936_605, 0).saturating_mul(r.into())) + // Minimum execution time: 2_324_000 picoseconds. + Weight::from_parts(2_385_000, 0) + // Standard Error: 9_154 + .saturating_add(Weight::from_parts(1_858_617, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32eq(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_291_000 picoseconds. - Weight::from_parts(2_364_000, 0) - // Standard Error: 8_346 - .saturating_add(Weight::from_parts(1_222_521, 0).saturating_mul(r.into())) + // Minimum execution time: 2_237_000 picoseconds. + Weight::from_parts(2_302_000, 0) + // Standard Error: 7_801 + .saturating_add(Weight::from_parts(1_226_411, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64ne(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_345_000 picoseconds. - Weight::from_parts(2_452_000, 0) - // Standard Error: 10_232 - .saturating_add(Weight::from_parts(1_883_867, 0).saturating_mul(r.into())) + // Minimum execution time: 2_265_000 picoseconds. + Weight::from_parts(2_358_000, 0) + // Standard Error: 9_102 + .saturating_add(Weight::from_parts(1_866_723, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32ne(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_323_000 picoseconds. - Weight::from_parts(2_387_000, 0) - // Standard Error: 7_581 - .saturating_add(Weight::from_parts(1_200_178, 0).saturating_mul(r.into())) + // Minimum execution time: 2_267_000 picoseconds. + Weight::from_parts(2_381_000, 0) + // Standard Error: 8_629 + .saturating_add(Weight::from_parts(1_209_968, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64lts(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_410_000 picoseconds. - Weight::from_parts(2_459_000, 0) - // Standard Error: 11_139 - .saturating_add(Weight::from_parts(1_877_766, 0).saturating_mul(r.into())) + // Minimum execution time: 2_274_000 picoseconds. + Weight::from_parts(2_330_000, 0) + // Standard Error: 9_193 + .saturating_add(Weight::from_parts(1_895_140, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32lts(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_273_000 picoseconds. - Weight::from_parts(2_387_000, 0) - // Standard Error: 8_083 - .saturating_add(Weight::from_parts(1_217_904, 0).saturating_mul(r.into())) + // Minimum execution time: 2_306_000 picoseconds. + Weight::from_parts(2_394_000, 0) + // Standard Error: 7_780 + .saturating_add(Weight::from_parts(1_209_776, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64ltu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_403_000 picoseconds. - Weight::from_parts(2_482_000, 0) - // Standard Error: 11_044 - .saturating_add(Weight::from_parts(1_956_302, 0).saturating_mul(r.into())) + // Minimum execution time: 2_273_000 picoseconds. + Weight::from_parts(2_395_000, 0) + // Standard Error: 8_868 + .saturating_add(Weight::from_parts(1_845_417, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32ltu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_353_000 picoseconds. - Weight::from_parts(2_420_000, 0) - // Standard Error: 7_870 - .saturating_add(Weight::from_parts(1_213_570, 0).saturating_mul(r.into())) + // Minimum execution time: 2_280_000 picoseconds. + Weight::from_parts(2_360_000, 0) + // Standard Error: 8_139 + .saturating_add(Weight::from_parts(1_208_611, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64gts(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_364_000 picoseconds. - Weight::from_parts(2_430_000, 0) - // Standard Error: 10_577 - .saturating_add(Weight::from_parts(1_968_043, 0).saturating_mul(r.into())) + // Minimum execution time: 2_299_000 picoseconds. + Weight::from_parts(2_335_000, 0) + // Standard Error: 8_008 + .saturating_add(Weight::from_parts(1_833_636, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32gts(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_328_000 picoseconds. - Weight::from_parts(2_442_000, 0) - // Standard Error: 7_838 - .saturating_add(Weight::from_parts(1_267_211, 0).saturating_mul(r.into())) + // Minimum execution time: 2_222_000 picoseconds. + Weight::from_parts(2_376_000, 0) + // Standard Error: 7_996 + .saturating_add(Weight::from_parts(1_224_203, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64gtu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_395_000 picoseconds. - Weight::from_parts(2_460_000, 0) - // Standard Error: 10_856 - .saturating_add(Weight::from_parts(1_910_357, 0).saturating_mul(r.into())) + // Minimum execution time: 2_371_000 picoseconds. + Weight::from_parts(2_421_000, 0) + // Standard Error: 9_119 + .saturating_add(Weight::from_parts(1_821_158, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32gtu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_343_000 picoseconds. - Weight::from_parts(2_409_000, 0) - // Standard Error: 5_786 - .saturating_add(Weight::from_parts(1_128_653, 0).saturating_mul(r.into())) + // Minimum execution time: 2_305_000 picoseconds. + Weight::from_parts(2_418_000, 0) + // Standard Error: 7_441 + .saturating_add(Weight::from_parts(1_186_995, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64les(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_318_000 picoseconds. - Weight::from_parts(2_433_000, 0) - // Standard Error: 10_344 - .saturating_add(Weight::from_parts(1_897_480, 0).saturating_mul(r.into())) + // Minimum execution time: 2_340_000 picoseconds. + Weight::from_parts(2_362_000, 0) + // Standard Error: 8_788 + .saturating_add(Weight::from_parts(1_811_701, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32les(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_355_000 picoseconds. - Weight::from_parts(2_460_000, 0) - // Standard Error: 6_963 - .saturating_add(Weight::from_parts(1_125_698, 0).saturating_mul(r.into())) + // Minimum execution time: 2_352_000 picoseconds. + Weight::from_parts(2_431_000, 0) + // Standard Error: 6_620 + .saturating_add(Weight::from_parts(1_171_906, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64leu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_356_000 picoseconds. - Weight::from_parts(2_447_000, 0) - // Standard Error: 8_285 - .saturating_add(Weight::from_parts(1_848_149, 0).saturating_mul(r.into())) + // Minimum execution time: 2_352_000 picoseconds. + Weight::from_parts(2_380_000, 0) + // Standard Error: 8_554 + .saturating_add(Weight::from_parts(1_821_955, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32leu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_327_000 picoseconds. - Weight::from_parts(2_394_000, 0) - // Standard Error: 7_282 - .saturating_add(Weight::from_parts(1_176_423, 0).saturating_mul(r.into())) + // Minimum execution time: 2_299_000 picoseconds. + Weight::from_parts(2_389_000, 0) + // Standard Error: 7_710 + .saturating_add(Weight::from_parts(1_188_722, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64ges(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_372_000 picoseconds. - Weight::from_parts(2_439_000, 0) - // Standard Error: 9_207 - .saturating_add(Weight::from_parts(1_837_009, 0).saturating_mul(r.into())) + // Minimum execution time: 2_325_000 picoseconds. + Weight::from_parts(2_387_000, 0) + // Standard Error: 10_150 + .saturating_add(Weight::from_parts(1_912_877, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32ges(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_368_000 picoseconds. - Weight::from_parts(2_427_000, 0) - // Standard Error: 8_320 - .saturating_add(Weight::from_parts(1_231_088, 0).saturating_mul(r.into())) + // Minimum execution time: 2_377_000 picoseconds. + Weight::from_parts(2_423_000, 0) + // Standard Error: 6_824 + .saturating_add(Weight::from_parts(1_181_831, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64geu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_373_000 picoseconds. - Weight::from_parts(2_461_000, 0) - // Standard Error: 9_499 - .saturating_add(Weight::from_parts(1_922_588, 0).saturating_mul(r.into())) + // Minimum execution time: 2_292_000 picoseconds. + Weight::from_parts(2_384_000, 0) + // Standard Error: 9_214 + .saturating_add(Weight::from_parts(1_842_825, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32geu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_387_000 picoseconds. - Weight::from_parts(2_455_000, 0) - // Standard Error: 7_681 - .saturating_add(Weight::from_parts(1_198_894, 0).saturating_mul(r.into())) + // Minimum execution time: 2_283_000 picoseconds. + Weight::from_parts(2_344_000, 0) + // Standard Error: 7_145 + .saturating_add(Weight::from_parts(1_216_207, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64add(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_308_000 picoseconds. - Weight::from_parts(2_389_000, 0) - // Standard Error: 7_797 - .saturating_add(Weight::from_parts(1_286_566, 0).saturating_mul(r.into())) + // Minimum execution time: 2_232_000 picoseconds. + Weight::from_parts(2_391_000, 0) + // Standard Error: 9_159 + .saturating_add(Weight::from_parts(1_360_135, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32add(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_329_000 picoseconds. - Weight::from_parts(2_389_000, 0) - // Standard Error: 4_968 - .saturating_add(Weight::from_parts(645_254, 0).saturating_mul(r.into())) + // Minimum execution time: 2_279_000 picoseconds. + Weight::from_parts(2_379_000, 0) + // Standard Error: 5_400 + .saturating_add(Weight::from_parts(704_012, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64sub(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_409_000 picoseconds. - Weight::from_parts(2_489_000, 0) - // Standard Error: 7_055 - .saturating_add(Weight::from_parts(1_232_084, 0).saturating_mul(r.into())) + // Minimum execution time: 2_355_000 picoseconds. + Weight::from_parts(2_402_000, 0) + // Standard Error: 8_632 + .saturating_add(Weight::from_parts(1_358_130, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32sub(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_371_000 picoseconds. - Weight::from_parts(2_420_000, 0) - // Standard Error: 4_348 - .saturating_add(Weight::from_parts(633_810, 0).saturating_mul(r.into())) + // Minimum execution time: 2_365_000 picoseconds. + Weight::from_parts(2_389_000, 0) + // Standard Error: 4_840 + .saturating_add(Weight::from_parts(658_882, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64mul(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_336_000 picoseconds. - Weight::from_parts(2_413_000, 0) - // Standard Error: 8_202 - .saturating_add(Weight::from_parts(1_777_425, 0).saturating_mul(r.into())) + // Minimum execution time: 2_209_000 picoseconds. + Weight::from_parts(2_324_000, 0) + // Standard Error: 8_679 + .saturating_add(Weight::from_parts(1_840_263, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32mul(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_314_000 picoseconds. - Weight::from_parts(2_369_000, 0) - // Standard Error: 6_935 - .saturating_add(Weight::from_parts(1_201_570, 0).saturating_mul(r.into())) + // Minimum execution time: 2_258_000 picoseconds. + Weight::from_parts(2_382_000, 0) + // Standard Error: 7_484 + .saturating_add(Weight::from_parts(1_255_185, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64divs(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_276_000 picoseconds. - Weight::from_parts(6_846_840, 0) - // Standard Error: 17_822 - .saturating_add(Weight::from_parts(2_268_370, 0).saturating_mul(r.into())) + // Minimum execution time: 2_369_000 picoseconds. + Weight::from_parts(6_412_885, 0) + // Standard Error: 22_130 + .saturating_add(Weight::from_parts(2_376_785, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32divs(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_394_000 picoseconds. - Weight::from_parts(4_704_336, 0) - // Standard Error: 10_960 - .saturating_add(Weight::from_parts(2_182_711, 0).saturating_mul(r.into())) + // Minimum execution time: 2_266_000 picoseconds. + Weight::from_parts(2_981_330, 0) + // Standard Error: 11_996 + .saturating_add(Weight::from_parts(2_322_763, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64divu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_375_000 picoseconds. - Weight::from_parts(1_968_824, 0) - // Standard Error: 15_899 - .saturating_add(Weight::from_parts(2_762_269, 0).saturating_mul(r.into())) + // Minimum execution time: 2_240_000 picoseconds. + Weight::from_parts(7_628_007, 0) + // Standard Error: 29_510 + .saturating_add(Weight::from_parts(2_483_957, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32divu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_335_000 picoseconds. - Weight::from_parts(1_450_000, 0) - // Standard Error: 13_496 - .saturating_add(Weight::from_parts(2_401_407, 0).saturating_mul(r.into())) + // Minimum execution time: 2_387_000 picoseconds. + Weight::from_parts(4_910_027, 0) + // Standard Error: 23_548 + .saturating_add(Weight::from_parts(2_233_487, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64rems(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_448_000 picoseconds. - Weight::from_parts(2_513_000, 0) - // Standard Error: 19_401 - .saturating_add(Weight::from_parts(9_309_211, 0).saturating_mul(r.into())) + // Minimum execution time: 2_297_000 picoseconds. + Weight::from_parts(16_240_633, 0) + // Standard Error: 67_100 + .saturating_add(Weight::from_parts(8_506_720, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32rems(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_273_000 picoseconds. - Weight::from_parts(1_738_370, 0) - // Standard Error: 42_672 - .saturating_add(Weight::from_parts(7_512_557, 0).saturating_mul(r.into())) + // Minimum execution time: 2_234_000 picoseconds. + Weight::from_parts(2_498_693, 0) + // Standard Error: 48_996 + .saturating_add(Weight::from_parts(7_513_162, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64remu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_371_000 picoseconds. - Weight::from_parts(2_215_088, 0) - // Standard Error: 15_445 - .saturating_add(Weight::from_parts(2_956_278, 0).saturating_mul(r.into())) + // Minimum execution time: 2_221_000 picoseconds. + Weight::from_parts(5_074_264, 0) + // Standard Error: 23_109 + .saturating_add(Weight::from_parts(2_727_269, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32remu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_409_000 picoseconds. - Weight::from_parts(217_500, 0) - // Standard Error: 7_904 - .saturating_add(Weight::from_parts(2_576_151, 0).saturating_mul(r.into())) + // Minimum execution time: 2_283_000 picoseconds. + Weight::from_parts(2_057_554, 0) + // Standard Error: 15_404 + .saturating_add(Weight::from_parts(2_428_553, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64and(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_456_000 picoseconds. - Weight::from_parts(2_503_000, 0) - // Standard Error: 7_920 - .saturating_add(Weight::from_parts(1_321_543, 0).saturating_mul(r.into())) + // Minimum execution time: 2_250_000 picoseconds. + Weight::from_parts(2_359_000, 0) + // Standard Error: 8_133 + .saturating_add(Weight::from_parts(1_333_125, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32and(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_346_000 picoseconds. - Weight::from_parts(2_479_000, 0) - // Standard Error: 4_711 - .saturating_add(Weight::from_parts(689_892, 0).saturating_mul(r.into())) + // Minimum execution time: 2_251_000 picoseconds. + Weight::from_parts(2_372_000, 0) + // Standard Error: 4_205 + .saturating_add(Weight::from_parts(671_074, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64or(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_339_000 picoseconds. - Weight::from_parts(2_427_000, 0) - // Standard Error: 8_029 - .saturating_add(Weight::from_parts(1_256_838, 0).saturating_mul(r.into())) + // Minimum execution time: 2_257_000 picoseconds. + Weight::from_parts(2_323_000, 0) + // Standard Error: 7_098 + .saturating_add(Weight::from_parts(1_323_703, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32or(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_334_000 picoseconds. - Weight::from_parts(2_480_000, 0) - // Standard Error: 3_812 - .saturating_add(Weight::from_parts(607_420, 0).saturating_mul(r.into())) + // Minimum execution time: 2_247_000 picoseconds. + Weight::from_parts(2_372_000, 0) + // Standard Error: 6_649 + .saturating_add(Weight::from_parts(695_117, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64xor(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_328_000 picoseconds. - Weight::from_parts(2_392_000, 0) - // Standard Error: 7_362 - .saturating_add(Weight::from_parts(1_248_739, 0).saturating_mul(r.into())) + // Minimum execution time: 2_293_000 picoseconds. + Weight::from_parts(2_347_000, 0) + // Standard Error: 7_359 + .saturating_add(Weight::from_parts(1_355_885, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32xor(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_419_000 picoseconds. - Weight::from_parts(2_465_000, 0) - // Standard Error: 4_304 - .saturating_add(Weight::from_parts(604_813, 0).saturating_mul(r.into())) + // Minimum execution time: 2_239_000 picoseconds. + Weight::from_parts(2_335_000, 0) + // Standard Error: 4_076 + .saturating_add(Weight::from_parts(658_834, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64shl(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_298_000 picoseconds. - Weight::from_parts(2_433_000, 0) - // Standard Error: 8_043 - .saturating_add(Weight::from_parts(1_073_194, 0).saturating_mul(r.into())) + // Minimum execution time: 2_376_000 picoseconds. + Weight::from_parts(2_444_000, 0) + // Standard Error: 6_850 + .saturating_add(Weight::from_parts(1_191_253, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32shl(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_427_000 picoseconds. - Weight::from_parts(2_511_000, 0) - // Standard Error: 4_969 - .saturating_add(Weight::from_parts(594_802, 0).saturating_mul(r.into())) + // Minimum execution time: 2_240_000 picoseconds. + Weight::from_parts(2_310_000, 0) + // Standard Error: 4_398 + .saturating_add(Weight::from_parts(597_162, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64shrs(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_312_000 picoseconds. - Weight::from_parts(2_399_000, 0) - // Standard Error: 7_093 - .saturating_add(Weight::from_parts(1_110_114, 0).saturating_mul(r.into())) + // Minimum execution time: 2_338_000 picoseconds. + Weight::from_parts(2_421_000, 0) + // Standard Error: 8_320 + .saturating_add(Weight::from_parts(1_163_071, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32shrs(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_331_000 picoseconds. - Weight::from_parts(2_433_000, 0) - // Standard Error: 4_140 - .saturating_add(Weight::from_parts(600_354, 0).saturating_mul(r.into())) + // Minimum execution time: 2_376_000 picoseconds. + Weight::from_parts(2_464_000, 0) + // Standard Error: 5_750 + .saturating_add(Weight::from_parts(613_283, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64shru(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_300_000 picoseconds. - Weight::from_parts(2_419_000, 0) - // Standard Error: 7_150 - .saturating_add(Weight::from_parts(1_154_649, 0).saturating_mul(r.into())) + // Minimum execution time: 2_338_000 picoseconds. + Weight::from_parts(2_378_000, 0) + // Standard Error: 7_893 + .saturating_add(Weight::from_parts(1_161_655, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32shru(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_356_000 picoseconds. - Weight::from_parts(2_423_000, 0) - // Standard Error: 5_067 - .saturating_add(Weight::from_parts(594_487, 0).saturating_mul(r.into())) + // Minimum execution time: 2_260_000 picoseconds. + Weight::from_parts(2_351_000, 0) + // Standard Error: 3_972 + .saturating_add(Weight::from_parts(605_013, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64rotl(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_339_000 picoseconds. - Weight::from_parts(2_406_000, 0) - // Standard Error: 5_674 - .saturating_add(Weight::from_parts(1_051_819, 0).saturating_mul(r.into())) + // Minimum execution time: 2_324_000 picoseconds. + Weight::from_parts(2_375_000, 0) + // Standard Error: 7_329 + .saturating_add(Weight::from_parts(1_108_542, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32rotl(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_383_000 picoseconds. - Weight::from_parts(114_723, 0) - // Standard Error: 5_881 - .saturating_add(Weight::from_parts(646_798, 0).saturating_mul(r.into())) + // Minimum execution time: 2_342_000 picoseconds. + Weight::from_parts(2_465_000, 0) + // Standard Error: 5_553 + .saturating_add(Weight::from_parts(617_389, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64rotr(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_292_000 picoseconds. - Weight::from_parts(2_422_000, 0) - // Standard Error: 6_697 - .saturating_add(Weight::from_parts(1_053_580, 0).saturating_mul(r.into())) + // Minimum execution time: 2_260_000 picoseconds. + Weight::from_parts(2_419_000, 0) + // Standard Error: 8_448 + .saturating_add(Weight::from_parts(1_105_239, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32rotr(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_325_000 picoseconds. - Weight::from_parts(206_699, 0) - // Standard Error: 5_851 - .saturating_add(Weight::from_parts(639_333, 0).saturating_mul(r.into())) + // Minimum execution time: 2_255_000 picoseconds. + Weight::from_parts(2_321_000, 0) + // Standard Error: 5_862 + .saturating_add(Weight::from_parts(626_497, 0).saturating_mul(r.into())) } fn tasks_remove_resume_session() -> Weight { // Proof Size summary in bytes: // Measured: `352` // Estimated: `4169` - // Minimum execution time: 5_698_000 picoseconds. - Weight::from_parts(5_953_000, 4169) + // Minimum execution time: 5_780_000 picoseconds. + Weight::from_parts(6_083_000, 4169) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) } fn tasks_remove_gas_reservation() -> Weight { // Proof Size summary in bytes: - // Measured: `1003` - // Estimated: `23637` - // Minimum execution time: 61_615_000 picoseconds. - Weight::from_parts(64_309_000, 23637) + // Measured: `1039` + // Estimated: `23781` + // Minimum execution time: 62_100_000 picoseconds. + Weight::from_parts(64_771_000, 23781) .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().writes(6_u64)) } fn tasks_send_user_message_to_mailbox() -> Weight { // Proof Size summary in bytes: - // Measured: `784` - // Estimated: `21534` - // Minimum execution time: 43_449_000 picoseconds. - Weight::from_parts(44_990_000, 21534) + // Measured: `820` + // Estimated: `21750` + // Minimum execution time: 47_415_000 picoseconds. + Weight::from_parts(48_906_000, 21750) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().writes(5_u64)) } fn tasks_send_user_message() -> Weight { // Proof Size summary in bytes: - // Measured: `906` - // Estimated: `33891` - // Minimum execution time: 75_764_000 picoseconds. - Weight::from_parts(77_875_000, 33891) + // Measured: `942` + // Estimated: `34143` + // Minimum execution time: 76_882_000 picoseconds. + Weight::from_parts(79_728_000, 34143) .saturating_add(RocksDbWeight::get().reads(11_u64)) .saturating_add(RocksDbWeight::get().writes(10_u64)) } fn tasks_send_dispatch() -> Weight { // Proof Size summary in bytes: - // Measured: `591` - // Estimated: `19885` - // Minimum execution time: 31_362_000 picoseconds. - Weight::from_parts(32_425_000, 19885) + // Measured: `627` + // Estimated: `20101` + // Minimum execution time: 32_342_000 picoseconds. + Weight::from_parts(33_851_000, 20101) .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().writes(6_u64)) } fn tasks_wake_message() -> Weight { // Proof Size summary in bytes: - // Measured: `872` - // Estimated: `25908` - // Minimum execution time: 45_023_000 picoseconds. - Weight::from_parts(46_479_000, 25908) + // Measured: `908` + // Estimated: `26160` + // Minimum execution time: 50_697_000 picoseconds. + Weight::from_parts(53_632_000, 26160) .saturating_add(RocksDbWeight::get().reads(8_u64)) .saturating_add(RocksDbWeight::get().writes(6_u64)) } @@ -4103,37 +4107,37 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `80` // Estimated: `3545` - // Minimum execution time: 3_365_000 picoseconds. - Weight::from_parts(3_639_000, 3545) + // Minimum execution time: 3_467_000 picoseconds. + Weight::from_parts(3_690_000, 3545) .saturating_add(RocksDbWeight::get().reads(1_u64)) } fn tasks_remove_from_waitlist() -> Weight { // Proof Size summary in bytes: - // Measured: `1522` - // Estimated: `57192` - // Minimum execution time: 114_023_000 picoseconds. - Weight::from_parts(117_157_000, 57192) + // Measured: `1558` + // Estimated: `57552` + // Minimum execution time: 111_822_000 picoseconds. + Weight::from_parts(115_245_000, 57552) .saturating_add(RocksDbWeight::get().reads(16_u64)) .saturating_add(RocksDbWeight::get().writes(13_u64)) } fn tasks_remove_from_mailbox() -> Weight { // Proof Size summary in bytes: - // Measured: `1228` - // Estimated: `46026` - // Minimum execution time: 90_320_000 picoseconds. - Weight::from_parts(93_096_000, 46026) + // Measured: `1264` + // Estimated: `46350` + // Minimum execution time: 92_407_000 picoseconds. + Weight::from_parts(95_840_000, 46350) .saturating_add(RocksDbWeight::get().reads(14_u64)) .saturating_add(RocksDbWeight::get().writes(13_u64)) } /// The range of component `c` is `[0, 2044]`. fn tasks_pause_program(c: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `2200 + c * (16400 ±0)` - // Estimated: `19363 + c * (84480 ±0)` - // Minimum execution time: 28_326_000 picoseconds. - Weight::from_parts(28_612_000, 19363) - // Standard Error: 73_191 - .saturating_add(Weight::from_parts(39_403_570, 0).saturating_mul(c.into())) + // Measured: `2236 + c * (16400 ±0)` + // Estimated: `19543 + c * (84480 ±0)` + // Minimum execution time: 29_880_000 picoseconds. + Weight::from_parts(30_555_000, 19543) + // Standard Error: 65_806 + .saturating_add(Weight::from_parts(39_128_234, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(4_u64)) .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(c.into()))) .saturating_add(RocksDbWeight::get().writes(2_u64)) @@ -4143,12 +4147,12 @@ impl WeightInfo for () { /// The range of component `c` is `[0, 2044]`. fn tasks_pause_program_uninited(c: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `3025 + c * (42 ±0)` - // Estimated: `59431 + c * (2947 ±0)` - // Minimum execution time: 86_517_000 picoseconds. - Weight::from_parts(78_047_954, 59431) - // Standard Error: 2_660 - .saturating_add(Weight::from_parts(1_060_607, 0).saturating_mul(c.into())) + // Measured: `3061 + c * (42 ±0)` + // Estimated: `59827 + c * (2947 ±0)` + // Minimum execution time: 89_781_000 picoseconds. + Weight::from_parts(109_193_287, 59827) + // Standard Error: 2_877 + .saturating_add(Weight::from_parts(1_067_792, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(13_u64)) .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(c.into()))) .saturating_add(RocksDbWeight::get().writes(9_u64)) diff --git a/runtime/gear/src/weights/pallet_gear_voucher.rs b/runtime/gear/src/weights/pallet_gear_voucher.rs index 6d6889d1752..faa61af8320 100644 --- a/runtime/gear/src/weights/pallet_gear_voucher.rs +++ b/runtime/gear/src/weights/pallet_gear_voucher.rs @@ -19,13 +19,13 @@ //! Autogenerated weights for pallet_gear_voucher //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-09-11, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-09-28, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` //! CPU: `Intel(R) Xeon(R) Platinum 8375C CPU @ 2.90GHz` -//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("vara-dev"), DB CACHE: 1024 +//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("gear-dev"), DB CACHE: 1024 // Executed Command: -// ./target/production/gear benchmark pallet --chain=vara-dev --steps=50 --repeat=20 --pallet=pallet_gear_voucher --extrinsic=* --execution=wasm --wasm-execution=compiled --heap-pages=4096 --output=./scripts/benchmarking/weights-output/pallet_gear_voucher.rs --template=.maintain/frame-weight-template.hbs +// ./target/production/gear benchmark pallet --chain=gear-dev --steps=50 --repeat=20 --pallet=pallet_gear_voucher --extrinsic=* --execution=wasm --wasm-execution=compiled --heap-pages=4096 --output=./scripts/benchmarking/weights-output/pallet_gear_voucher.rs --template=.maintain/frame-weight-template.hbs #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(unused_parens)] @@ -47,8 +47,8 @@ impl pallet_gear_voucher::WeightInfo for SubstrateWeigh // Proof Size summary in bytes: // Measured: `101` // Estimated: `6196` - // Minimum execution time: 25_876_000 picoseconds. - Weight::from_parts(26_659_000, 6196) + // Minimum execution time: 26_404_000 picoseconds. + Weight::from_parts(27_288_000, 6196) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) } @@ -60,8 +60,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `101` // Estimated: `6196` - // Minimum execution time: 25_876_000 picoseconds. - Weight::from_parts(26_659_000, 6196) + // Minimum execution time: 26_404_000 picoseconds. + Weight::from_parts(27_288_000, 6196) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) } diff --git a/runtime/gear/src/weights/pallet_timestamp.rs b/runtime/gear/src/weights/pallet_timestamp.rs index 5c50f24c824..10108dcc046 100644 --- a/runtime/gear/src/weights/pallet_timestamp.rs +++ b/runtime/gear/src/weights/pallet_timestamp.rs @@ -19,13 +19,13 @@ //! Autogenerated weights for pallet_timestamp //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-09-11, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-09-28, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` //! CPU: `Intel(R) Xeon(R) Platinum 8375C CPU @ 2.90GHz` -//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("vara-dev"), DB CACHE: 1024 +//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("gear-dev"), DB CACHE: 1024 // Executed Command: -// ./target/production/gear benchmark pallet --chain=vara-dev --steps=50 --repeat=20 --pallet=pallet_timestamp --extrinsic=* --execution=wasm --wasm-execution=compiled --heap-pages=4096 --output=./scripts/benchmarking/weights-output/pallet_timestamp.rs --template=.maintain/frame-weight-template.hbs +// ./target/production/gear benchmark pallet --chain=gear-dev --steps=50 --repeat=20 --pallet=pallet_timestamp --extrinsic=* --execution=wasm --wasm-execution=compiled --heap-pages=4096 --output=./scripts/benchmarking/weights-output/pallet_timestamp.rs --template=.maintain/frame-weight-template.hbs #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(unused_parens)] @@ -48,8 +48,8 @@ impl pallet_timestamp::WeightInfo for SubstrateWeight pallet_timestamp::WeightInfo for SubstrateWeight pallet_utility::WeightInfo for SubstrateWeight // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 5_349_000 picoseconds. - Weight::from_parts(8_798_188, 0) - // Standard Error: 2_360 - .saturating_add(Weight::from_parts(3_859_914, 0).saturating_mul(c.into())) + // Minimum execution time: 5_345_000 picoseconds. + Weight::from_parts(4_423_143, 0) + // Standard Error: 4_589 + .saturating_add(Weight::from_parts(3_947_978, 0).saturating_mul(c.into())) } fn as_derivative() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 3_760_000 picoseconds. - Weight::from_parts(3_882_000, 0) + // Minimum execution time: 3_645_000 picoseconds. + Weight::from_parts(3_825_000, 0) } /// The range of component `c` is `[0, 1000]`. fn batch_all(c: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 5_343_000 picoseconds. - Weight::from_parts(6_613_150, 0) - // Standard Error: 2_902 - .saturating_add(Weight::from_parts(4_045_901, 0).saturating_mul(c.into())) + // Minimum execution time: 5_397_000 picoseconds. + Weight::from_parts(10_424_905, 0) + // Standard Error: 3_521 + .saturating_add(Weight::from_parts(4_132_846, 0).saturating_mul(c.into())) } fn dispatch_as() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 6_983_000 picoseconds. - Weight::from_parts(7_317_000, 0) + // Minimum execution time: 7_073_000 picoseconds. + Weight::from_parts(7_382_000, 0) } /// The range of component `c` is `[0, 1000]`. fn force_batch(c: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 5_419_000 picoseconds. - Weight::from_parts(9_009_348, 0) - // Standard Error: 2_400 - .saturating_add(Weight::from_parts(3_868_692, 0).saturating_mul(c.into())) + // Minimum execution time: 5_389_000 picoseconds. + Weight::from_parts(12_202_657, 0) + // Standard Error: 2_744 + .saturating_add(Weight::from_parts(3_910_883, 0).saturating_mul(c.into())) } } @@ -100,43 +100,43 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 5_349_000 picoseconds. - Weight::from_parts(8_798_188, 0) - // Standard Error: 2_360 - .saturating_add(Weight::from_parts(3_859_914, 0).saturating_mul(c.into())) + // Minimum execution time: 5_345_000 picoseconds. + Weight::from_parts(4_423_143, 0) + // Standard Error: 4_589 + .saturating_add(Weight::from_parts(3_947_978, 0).saturating_mul(c.into())) } fn as_derivative() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 3_760_000 picoseconds. - Weight::from_parts(3_882_000, 0) + // Minimum execution time: 3_645_000 picoseconds. + Weight::from_parts(3_825_000, 0) } /// The range of component `c` is `[0, 1000]`. fn batch_all(c: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 5_343_000 picoseconds. - Weight::from_parts(6_613_150, 0) - // Standard Error: 2_902 - .saturating_add(Weight::from_parts(4_045_901, 0).saturating_mul(c.into())) + // Minimum execution time: 5_397_000 picoseconds. + Weight::from_parts(10_424_905, 0) + // Standard Error: 3_521 + .saturating_add(Weight::from_parts(4_132_846, 0).saturating_mul(c.into())) } fn dispatch_as() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 6_983_000 picoseconds. - Weight::from_parts(7_317_000, 0) + // Minimum execution time: 7_073_000 picoseconds. + Weight::from_parts(7_382_000, 0) } /// The range of component `c` is `[0, 1000]`. fn force_batch(c: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 5_419_000 picoseconds. - Weight::from_parts(9_009_348, 0) - // Standard Error: 2_400 - .saturating_add(Weight::from_parts(3_868_692, 0).saturating_mul(c.into())) + // Minimum execution time: 5_389_000 picoseconds. + Weight::from_parts(12_202_657, 0) + // Standard Error: 2_744 + .saturating_add(Weight::from_parts(3_910_883, 0).saturating_mul(c.into())) } } diff --git a/runtime/vara/src/tests.rs b/runtime/vara/src/tests.rs index e784daf1847..c9b6fc48146 100644 --- a/runtime/vara/src/tests.rs +++ b/runtime/vara/src/tests.rs @@ -138,10 +138,10 @@ fn page_costs_heuristic_test() { let expected_pages_costs = PageCosts { lazy_pages_signal_read: 28_000_000.into(), lazy_pages_signal_write: 33_000_000.into(), - lazy_pages_signal_write_after_read: 9_500_000.into(), + lazy_pages_signal_write_after_read: 10_650_000.into(), lazy_pages_host_func_read: 29_000_000.into(), lazy_pages_host_func_write: 33_000_000.into(), - lazy_pages_host_func_write_after_read: 10_687_730.into(), + lazy_pages_host_func_write_after_read: 9_280_000.into(), load_page_data: 9_700_000.into(), upload_page_data: 104_000_000.into(), static_page: 100.into(), diff --git a/runtime/vara/src/weights/frame_system.rs b/runtime/vara/src/weights/frame_system.rs index 31dd34692d1..5ea8f3e415d 100644 --- a/runtime/vara/src/weights/frame_system.rs +++ b/runtime/vara/src/weights/frame_system.rs @@ -19,7 +19,7 @@ //! Autogenerated weights for frame_system //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-09-11, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-09-28, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` //! CPU: `Intel(R) Xeon(R) Platinum 8375C CPU @ 2.90GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("vara-dev"), DB CACHE: 1024 @@ -53,27 +53,27 @@ impl frame_system::WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_562_000 picoseconds. - Weight::from_parts(1_066_991, 0) + // Minimum execution time: 1_621_000 picoseconds. + Weight::from_parts(801_681, 0) // Standard Error: 0 - .saturating_add(Weight::from_parts(461, 0).saturating_mul(b.into())) + .saturating_add(Weight::from_parts(460, 0).saturating_mul(b.into())) } /// The range of component `b` is `[0, 1310720]`. fn remark_with_event(b: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 5_949_000 picoseconds. - Weight::from_parts(6_153_000, 0) + // Minimum execution time: 6_227_000 picoseconds. + Weight::from_parts(6_365_000, 0) // Standard Error: 0 - .saturating_add(Weight::from_parts(1_441, 0).saturating_mul(b.into())) + .saturating_add(Weight::from_parts(1_438, 0).saturating_mul(b.into())) } fn set_heap_pages() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `1485` - // Minimum execution time: 3_113_000 picoseconds. - Weight::from_parts(3_394_000, 1485) + // Minimum execution time: 3_026_000 picoseconds. + Weight::from_parts(3_370_000, 1485) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) } @@ -82,10 +82,10 @@ impl frame_system::WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_578_000 picoseconds. - Weight::from_parts(1_632_000, 0) - // Standard Error: 994 - .saturating_add(Weight::from_parts(687_989, 0).saturating_mul(i.into())) + // Minimum execution time: 1_514_000 picoseconds. + Weight::from_parts(1_609_000, 0) + // Standard Error: 921 + .saturating_add(Weight::from_parts(720_053, 0).saturating_mul(i.into())) .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(i.into()))) } /// The range of component `i` is `[0, 1000]`. @@ -93,10 +93,10 @@ impl frame_system::WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_593_000 picoseconds. - Weight::from_parts(1_667_000, 0) - // Standard Error: 783 - .saturating_add(Weight::from_parts(535_872, 0).saturating_mul(i.into())) + // Minimum execution time: 1_578_000 picoseconds. + Weight::from_parts(1_637_000, 0) + // Standard Error: 781 + .saturating_add(Weight::from_parts(547_705, 0).saturating_mul(i.into())) .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(i.into()))) } /// The range of component `p` is `[0, 1000]`. @@ -104,10 +104,10 @@ impl frame_system::WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `82 + p * (69 ±0)` // Estimated: `89 + p * (70 ±0)` - // Minimum execution time: 3_345_000 picoseconds. - Weight::from_parts(3_470_000, 89) - // Standard Error: 1_511 - .saturating_add(Weight::from_parts(1_126_865, 0).saturating_mul(p.into())) + // Minimum execution time: 3_321_000 picoseconds. + Weight::from_parts(3_491_000, 89) + // Standard Error: 1_283 + .saturating_add(Weight::from_parts(1_144_029, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(p.into()))) .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(p.into()))) .saturating_add(Weight::from_parts(0, 70).saturating_mul(p.into())) @@ -121,27 +121,27 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_562_000 picoseconds. - Weight::from_parts(1_066_991, 0) + // Minimum execution time: 1_621_000 picoseconds. + Weight::from_parts(801_681, 0) // Standard Error: 0 - .saturating_add(Weight::from_parts(461, 0).saturating_mul(b.into())) + .saturating_add(Weight::from_parts(460, 0).saturating_mul(b.into())) } /// The range of component `b` is `[0, 1310720]`. fn remark_with_event(b: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 5_949_000 picoseconds. - Weight::from_parts(6_153_000, 0) + // Minimum execution time: 6_227_000 picoseconds. + Weight::from_parts(6_365_000, 0) // Standard Error: 0 - .saturating_add(Weight::from_parts(1_441, 0).saturating_mul(b.into())) + .saturating_add(Weight::from_parts(1_438, 0).saturating_mul(b.into())) } fn set_heap_pages() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `1485` - // Minimum execution time: 3_113_000 picoseconds. - Weight::from_parts(3_394_000, 1485) + // Minimum execution time: 3_026_000 picoseconds. + Weight::from_parts(3_370_000, 1485) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) } @@ -150,10 +150,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_578_000 picoseconds. - Weight::from_parts(1_632_000, 0) - // Standard Error: 994 - .saturating_add(Weight::from_parts(687_989, 0).saturating_mul(i.into())) + // Minimum execution time: 1_514_000 picoseconds. + Weight::from_parts(1_609_000, 0) + // Standard Error: 921 + .saturating_add(Weight::from_parts(720_053, 0).saturating_mul(i.into())) .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(i.into()))) } /// The range of component `i` is `[0, 1000]`. @@ -161,10 +161,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_593_000 picoseconds. - Weight::from_parts(1_667_000, 0) - // Standard Error: 783 - .saturating_add(Weight::from_parts(535_872, 0).saturating_mul(i.into())) + // Minimum execution time: 1_578_000 picoseconds. + Weight::from_parts(1_637_000, 0) + // Standard Error: 781 + .saturating_add(Weight::from_parts(547_705, 0).saturating_mul(i.into())) .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(i.into()))) } /// The range of component `p` is `[0, 1000]`. @@ -172,10 +172,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `82 + p * (69 ±0)` // Estimated: `89 + p * (70 ±0)` - // Minimum execution time: 3_345_000 picoseconds. - Weight::from_parts(3_470_000, 89) - // Standard Error: 1_511 - .saturating_add(Weight::from_parts(1_126_865, 0).saturating_mul(p.into())) + // Minimum execution time: 3_321_000 picoseconds. + Weight::from_parts(3_491_000, 89) + // Standard Error: 1_283 + .saturating_add(Weight::from_parts(1_144_029, 0).saturating_mul(p.into())) .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(p.into()))) .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(p.into()))) .saturating_add(Weight::from_parts(0, 70).saturating_mul(p.into())) diff --git a/runtime/vara/src/weights/pallet_balances.rs b/runtime/vara/src/weights/pallet_balances.rs index f096d50de43..183de08edf7 100644 --- a/runtime/vara/src/weights/pallet_balances.rs +++ b/runtime/vara/src/weights/pallet_balances.rs @@ -19,7 +19,7 @@ //! Autogenerated weights for pallet_balances //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-09-11, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-09-28, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` //! CPU: `Intel(R) Xeon(R) Platinum 8375C CPU @ 2.90GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("vara-dev"), DB CACHE: 1024 @@ -53,8 +53,8 @@ impl pallet_balances::WeightInfo for SubstrateWeight // Proof Size summary in bytes: // Measured: `0` // Estimated: `3593` - // Minimum execution time: 29_789_000 picoseconds. - Weight::from_parts(30_683_000, 3593) + // Minimum execution time: 29_968_000 picoseconds. + Weight::from_parts(30_716_000, 3593) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -62,8 +62,8 @@ impl pallet_balances::WeightInfo for SubstrateWeight // Proof Size summary in bytes: // Measured: `0` // Estimated: `3593` - // Minimum execution time: 21_425_000 picoseconds. - Weight::from_parts(21_900_000, 3593) + // Minimum execution time: 21_506_000 picoseconds. + Weight::from_parts(22_300_000, 3593) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -71,8 +71,8 @@ impl pallet_balances::WeightInfo for SubstrateWeight // Proof Size summary in bytes: // Measured: `103` // Estimated: `3593` - // Minimum execution time: 12_387_000 picoseconds. - Weight::from_parts(12_754_000, 3593) + // Minimum execution time: 12_576_000 picoseconds. + Weight::from_parts(13_031_000, 3593) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -80,8 +80,8 @@ impl pallet_balances::WeightInfo for SubstrateWeight // Proof Size summary in bytes: // Measured: `103` // Estimated: `3593` - // Minimum execution time: 15_196_000 picoseconds. - Weight::from_parts(15_778_000, 3593) + // Minimum execution time: 15_673_000 picoseconds. + Weight::from_parts(16_155_000, 3593) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -89,8 +89,8 @@ impl pallet_balances::WeightInfo for SubstrateWeight // Proof Size summary in bytes: // Measured: `103` // Estimated: `6196` - // Minimum execution time: 31_544_000 picoseconds. - Weight::from_parts(32_018_000, 6196) + // Minimum execution time: 32_028_000 picoseconds. + Weight::from_parts(32_821_000, 6196) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) } @@ -98,8 +98,8 @@ impl pallet_balances::WeightInfo for SubstrateWeight // Proof Size summary in bytes: // Measured: `0` // Estimated: `3593` - // Minimum execution time: 28_027_000 picoseconds. - Weight::from_parts(29_047_000, 3593) + // Minimum execution time: 27_510_000 picoseconds. + Weight::from_parts(28_346_000, 3593) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -107,8 +107,8 @@ impl pallet_balances::WeightInfo for SubstrateWeight // Proof Size summary in bytes: // Measured: `103` // Estimated: `3593` - // Minimum execution time: 11_796_000 picoseconds. - Weight::from_parts(12_239_000, 3593) + // Minimum execution time: 12_286_000 picoseconds. + Weight::from_parts(12_686_000, 3593) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -120,8 +120,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `3593` - // Minimum execution time: 29_789_000 picoseconds. - Weight::from_parts(30_683_000, 3593) + // Minimum execution time: 29_968_000 picoseconds. + Weight::from_parts(30_716_000, 3593) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -129,8 +129,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `3593` - // Minimum execution time: 21_425_000 picoseconds. - Weight::from_parts(21_900_000, 3593) + // Minimum execution time: 21_506_000 picoseconds. + Weight::from_parts(22_300_000, 3593) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -138,8 +138,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `103` // Estimated: `3593` - // Minimum execution time: 12_387_000 picoseconds. - Weight::from_parts(12_754_000, 3593) + // Minimum execution time: 12_576_000 picoseconds. + Weight::from_parts(13_031_000, 3593) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -147,8 +147,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `103` // Estimated: `3593` - // Minimum execution time: 15_196_000 picoseconds. - Weight::from_parts(15_778_000, 3593) + // Minimum execution time: 15_673_000 picoseconds. + Weight::from_parts(16_155_000, 3593) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -156,8 +156,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `103` // Estimated: `6196` - // Minimum execution time: 31_544_000 picoseconds. - Weight::from_parts(32_018_000, 6196) + // Minimum execution time: 32_028_000 picoseconds. + Weight::from_parts(32_821_000, 6196) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) } @@ -165,8 +165,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `3593` - // Minimum execution time: 28_027_000 picoseconds. - Weight::from_parts(29_047_000, 3593) + // Minimum execution time: 27_510_000 picoseconds. + Weight::from_parts(28_346_000, 3593) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -174,8 +174,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `103` // Estimated: `3593` - // Minimum execution time: 11_796_000 picoseconds. - Weight::from_parts(12_239_000, 3593) + // Minimum execution time: 12_286_000 picoseconds. + Weight::from_parts(12_686_000, 3593) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } diff --git a/runtime/vara/src/weights/pallet_gear.rs b/runtime/vara/src/weights/pallet_gear.rs index b5d0477da33..c7939a1f341 100644 --- a/runtime/vara/src/weights/pallet_gear.rs +++ b/runtime/vara/src/weights/pallet_gear.rs @@ -19,13 +19,13 @@ //! Autogenerated weights for pallet_gear //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-09-21, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-09-28, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` //! CPU: `Intel(R) Xeon(R) Platinum 8375C CPU @ 2.90GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("vara-dev"), DB CACHE: 1024 // Executed Command: -// ./target/production/gear benchmark pallet --chain=vara-dev --steps=50 --repeat=20 --pallet=pallet_gear --extrinsic=* --execution=wasm --wasm-execution=compiled --heap-pages=4096 --output=./scripts/benchmarking/weights-output/pallet_gear.rs --template=.maintain/frame-weight-template.hbs +// ./target/production/gear benchmark pallet --chain=vara-dev --steps=50 --repeat=20 --pallet=pallet_gear --extrinsic=alloc,alloc_in_handle,alloc_per_page,claim_value,create_program,db_read_per_kb,db_write_per_kb,free,gr_block_height,gr_block_timestamp,gr_create_program,gr_create_program_per_kb,gr_create_program_wgas,gr_create_program_wgas_per_kb,gr_debug,gr_debug_per_kb,gr_gas_available,gr_message_id,gr_pay_program_rent,gr_program_id,gr_random,gr_read,gr_read_per_kb,gr_reply_code,gr_reply_deposit,gr_reply_per_kb,gr_reply_push,gr_reply_push_input,gr_reply_push_input_per_kb,gr_reply_push_per_kb,gr_reply_to,gr_reply_wgas_per_kb,gr_reservation_reply_commit_per_kb,gr_reservation_reply_per_kb,gr_reservation_send,gr_reservation_send_commit,gr_reservation_send_per_kb,gr_reserve_gas,gr_send,gr_send_commit,gr_send_commit_wgas,gr_send_init,gr_send_input,gr_send_input_wgas,gr_send_per_kb,gr_send_push,gr_send_push_input,gr_send_push_input_per_kb,gr_send_push_per_kb,gr_send_wgas,gr_send_wgas_per_kb,gr_signal_code,gr_signal_from,gr_size,gr_source,gr_system_reserve_gas,gr_unreserve_gas,gr_value,gr_value_available,gr_wake,initial_allocation,instantiate_module_per_kb,instr_br,instr_br_if,instr_br_table,instr_br_table_per_entry,instr_call,instr_call_const,instr_call_indirect,instr_call_indirect_per_param,instr_call_per_local,instr_global_get,instr_global_set,instr_i32add,instr_i32and,instr_i32clz,instr_i32ctz,instr_i32divs,instr_i32divu,instr_i32eq,instr_i32eqz,instr_i32extend16s,instr_i32extend8s,instr_i32ges,instr_i32geu,instr_i32gts,instr_i32gtu,instr_i32les,instr_i32leu,instr_i32load,instr_i32lts,instr_i32ltu,instr_i32mul,instr_i32ne,instr_i32or,instr_i32popcnt,instr_i32rems,instr_i32remu,instr_i32rotl,instr_i32rotr,instr_i32shl,instr_i32shrs,instr_i32shru,instr_i32store,instr_i32sub,instr_i32wrapi64,instr_i32xor,instr_i64add,instr_i64and,instr_i64clz,instr_i64ctz,instr_i64divs,instr_i64divu,instr_i64eq,instr_i64eqz,instr_i64extend16s,instr_i64extend32s,instr_i64extend8s,instr_i64extendsi32,instr_i64extendui32,instr_i64ges,instr_i64geu,instr_i64gts,instr_i64gtu,instr_i64les,instr_i64leu,instr_i64load,instr_i64lts,instr_i64ltu,instr_i64mul,instr_i64ne,instr_i64or,instr_i64popcnt,instr_i64rems,instr_i64remu,instr_i64rotl,instr_i64rotr,instr_i64shl,instr_i64shrs,instr_i64shru,instr_i64store,instr_i64sub,instr_i64xor,instr_if,instr_local_get,instr_local_set,instr_local_tee,instr_memory_current,instr_select,lazy_pages_host_func_read,lazy_pages_host_func_write,lazy_pages_host_func_write_after_read,lazy_pages_load_page_storage_data,lazy_pages_signal_read,lazy_pages_signal_write,lazy_pages_signal_write_after_read,mem_grow,pay_program_rent,reinstrument_per_kb,resume_session_commit,resume_session_init,resume_session_push,send_message,send_reply,tasks_pause_program,tasks_pause_program_uninited,tasks_remove_from_mailbox,tasks_remove_from_waitlist,tasks_remove_gas_reservation,tasks_remove_resume_session,tasks_send_dispatch,tasks_send_user_message,tasks_send_user_message_to_mailbox,tasks_wake_message,tasks_wake_message_no_wake,upload_code,upload_program --execution=wasm --wasm-execution=compiled --heap-pages=4096 --output=./scripts/benchmarking/weights-output/pallet_gear.rs --template=.maintain/frame-weight-template.hbs #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(unused_parens)] @@ -37,6 +37,19 @@ use sp_std::marker::PhantomData; /// Weight functions needed for pallet_gear. pub trait WeightInfo { + fn gr_reply(r: u32, ) -> Weight; + fn gr_reply_wgas(r: u32, ) -> Weight; + fn gr_reply_commit(r: u32, ) -> Weight; + fn gr_reply_commit_wgas(r: u32, ) -> Weight; + fn gr_reply_input(r: u32, ) -> Weight; + fn gr_reply_input_wgas(r: u32, ) -> Weight; + fn gr_reservation_reply(r: u32, ) -> Weight; + fn gr_reservation_reply_commit(r: u32, ) -> Weight; + fn gr_exit(r: u32, ) -> Weight; + fn gr_leave(r: u32, ) -> Weight; + fn gr_wait(r: u32, ) -> Weight; + fn gr_wait_for(r: u32, ) -> Weight; + fn gr_wait_up_to(r: u32, ) -> Weight; fn db_write_per_kb(c: u32, ) -> Weight; fn db_read_per_kb(c: u32, ) -> Weight; fn instantiate_module_per_kb(c: u32, ) -> Weight; @@ -86,19 +99,11 @@ pub trait WeightInfo { fn gr_reservation_send(r: u32, ) -> Weight; fn gr_reservation_send_per_kb(n: u32, ) -> Weight; fn gr_reservation_send_commit(r: u32, ) -> Weight; - fn gr_reply(r: u32, ) -> Weight; fn gr_reply_per_kb(n: u32, ) -> Weight; - fn gr_reply_wgas(r: u32, ) -> Weight; fn gr_reply_wgas_per_kb(n: u32, ) -> Weight; - fn gr_reply_commit(r: u32, ) -> Weight; - fn gr_reply_commit_wgas(r: u32, ) -> Weight; fn gr_reply_push(r: u32, ) -> Weight; fn gr_reply_push_per_kb(n: u32, ) -> Weight; - fn gr_reply_input(r: u32, ) -> Weight; - fn gr_reply_input_wgas(r: u32, ) -> Weight; - fn gr_reservation_reply(r: u32, ) -> Weight; fn gr_reservation_reply_per_kb(n: u32, ) -> Weight; - fn gr_reservation_reply_commit(r: u32, ) -> Weight; fn gr_reservation_reply_commit_per_kb(n: u32, ) -> Weight; fn gr_reply_to(r: u32, ) -> Weight; fn gr_signal_code(r: u32, ) -> Weight; @@ -110,11 +115,6 @@ pub trait WeightInfo { fn gr_debug(r: u32, ) -> Weight; fn gr_debug_per_kb(n: u32, ) -> Weight; fn gr_reply_code(r: u32, ) -> Weight; - fn gr_exit(r: u32, ) -> Weight; - fn gr_leave(r: u32, ) -> Weight; - fn gr_wait(r: u32, ) -> Weight; - fn gr_wait_for(r: u32, ) -> Weight; - fn gr_wait_up_to(r: u32, ) -> Weight; fn gr_wake(r: u32, ) -> Weight; fn gr_create_program(r: u32, ) -> Weight; fn gr_create_program_per_kb(p: u32, s: u32, ) -> Weight; @@ -237,6 +237,136 @@ pub trait WeightInfo { /// Weights for pallet_gear using the Gear node and recommended hardware. pub struct SubstrateWeight(PhantomData); impl pallet_gear::WeightInfo for SubstrateWeight { + /// The range of component `r` is `[0, 1]`. + fn gr_reply(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 94_967_000 picoseconds. + Weight::from_parts(100_769_202, 0) + // Standard Error: 78_239 + .saturating_add(Weight::from_parts(21_623_874, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_reply_wgas(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 96_625_000 picoseconds. + Weight::from_parts(103_100_672, 0) + // Standard Error: 79_915 + .saturating_add(Weight::from_parts(18_339_856, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_reply_commit(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 95_620_000 picoseconds. + Weight::from_parts(102_660_230, 0) + // Standard Error: 81_604 + .saturating_add(Weight::from_parts(18_180_584, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_reply_commit_wgas(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 95_037_000 picoseconds. + Weight::from_parts(101_912_864, 0) + // Standard Error: 84_108 + .saturating_add(Weight::from_parts(20_742_928, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_reply_input(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 716_479_000 picoseconds. + Weight::from_parts(752_477_538, 0) + // Standard Error: 630_784 + .saturating_add(Weight::from_parts(22_929_588, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_reply_input_wgas(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 726_949_000 picoseconds. + Weight::from_parts(774_347_474, 0) + // Standard Error: 902_271 + .saturating_add(Weight::from_parts(17_273_758, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_reservation_reply(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 103_653_000 picoseconds. + Weight::from_parts(110_681_190, 0) + // Standard Error: 90_520 + .saturating_add(Weight::from_parts(12_801_500, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_reservation_reply_commit(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 105_389_000 picoseconds. + Weight::from_parts(113_272_838, 0) + // Standard Error: 89_344 + .saturating_add(Weight::from_parts(5_340_718, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_exit(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 96_868_000 picoseconds. + Weight::from_parts(104_048_366, 0) + // Standard Error: 2_216_528 + .saturating_add(Weight::from_parts(541_182_376, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_leave(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 94_494_000 picoseconds. + Weight::from_parts(103_419_240, 0) + // Standard Error: 2_066_261 + .saturating_add(Weight::from_parts(536_063_286, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_wait(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 96_167_000 picoseconds. + Weight::from_parts(103_413_378, 0) + // Standard Error: 2_011_359 + .saturating_add(Weight::from_parts(519_142_196, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_wait_for(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 93_437_000 picoseconds. + Weight::from_parts(100_205_340, 0) + // Standard Error: 2_405_150 + .saturating_add(Weight::from_parts(547_275_968, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_wait_up_to(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 95_803_000 picoseconds. + Weight::from_parts(102_665_234, 0) + // Standard Error: 2_225_197 + .saturating_add(Weight::from_parts(553_575_546, 0).saturating_mul(r.into())) + } fn allocation_cost() -> Weight { // To be changed with the proper value. T::DbWeight::get().writes(1) @@ -256,10 +386,10 @@ impl pallet_gear::WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_023_000 picoseconds. - Weight::from_parts(1_051_000, 0) - // Standard Error: 912 - .saturating_add(Weight::from_parts(213_761, 0).saturating_mul(c.into())) + // Minimum execution time: 976_000 picoseconds. + Weight::from_parts(1_072_000, 0) + // Standard Error: 699 + .saturating_add(Weight::from_parts(245_833, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().writes(1_u64)) } /// The range of component `c` is `[0, 512]`. @@ -267,10 +397,10 @@ impl pallet_gear::WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `146 + c * (1024 ±0)` // Estimated: `3610 + c * (1024 ±0)` - // Minimum execution time: 3_252_000 picoseconds. - Weight::from_parts(3_416_000, 3610) - // Standard Error: 1_261 - .saturating_add(Weight::from_parts(689_572, 0).saturating_mul(c.into())) + // Minimum execution time: 3_396_000 picoseconds. + Weight::from_parts(3_490_000, 3610) + // Standard Error: 1_049 + .saturating_add(Weight::from_parts(676_643, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(Weight::from_parts(0, 1024).saturating_mul(c.into())) } @@ -279,17 +409,17 @@ impl pallet_gear::WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 59_805_000 picoseconds. - Weight::from_parts(86_729_126, 0) - // Standard Error: 7_023 - .saturating_add(Weight::from_parts(2_475_519, 0).saturating_mul(c.into())) + // Minimum execution time: 62_736_000 picoseconds. + Weight::from_parts(76_636_221, 0) + // Standard Error: 9_825 + .saturating_add(Weight::from_parts(2_570_922, 0).saturating_mul(c.into())) } fn claim_value() -> Weight { // Proof Size summary in bytes: // Measured: `1372` // Estimated: `51905` - // Minimum execution time: 107_694_000 picoseconds. - Weight::from_parts(110_328_000, 51905) + // Minimum execution time: 111_461_000 picoseconds. + Weight::from_parts(114_029_000, 51905) .saturating_add(T::DbWeight::get().reads(15_u64)) .saturating_add(T::DbWeight::get().writes(12_u64)) } @@ -297,8 +427,8 @@ impl pallet_gear::WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `992` // Estimated: `21579` - // Minimum execution time: 55_980_000 picoseconds. - Weight::from_parts(56_766_000, 21579) + // Minimum execution time: 57_697_000 picoseconds. + Weight::from_parts(58_842_000, 21579) .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().writes(6_u64)) } @@ -306,8 +436,8 @@ impl pallet_gear::WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `638` // Estimated: `17486` - // Minimum execution time: 29_973_000 picoseconds. - Weight::from_parts(31_008_000, 17486) + // Minimum execution time: 30_530_000 picoseconds. + Weight::from_parts(32_003_000, 17486) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().writes(4_u64)) } @@ -316,10 +446,10 @@ impl pallet_gear::WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `355` // Estimated: `7640` - // Minimum execution time: 8_054_000 picoseconds. - Weight::from_parts(8_342_000, 7640) - // Standard Error: 17_771 - .saturating_add(Weight::from_parts(13_335_661, 0).saturating_mul(c.into())) + // Minimum execution time: 8_274_000 picoseconds. + Weight::from_parts(8_261_331, 7640) + // Standard Error: 41_108 + .saturating_add(Weight::from_parts(13_969_743, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) } @@ -328,10 +458,10 @@ impl pallet_gear::WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `1593 + c * (16389 ±0)` // Estimated: `43266 + c * (131112 ±0)` - // Minimum execution time: 72_178_000 picoseconds. - Weight::from_parts(73_341_000, 43266) - // Standard Error: 167_723 - .saturating_add(Weight::from_parts(54_442_045, 0).saturating_mul(c.into())) + // Minimum execution time: 74_444_000 picoseconds. + Weight::from_parts(75_016_000, 43266) + // Standard Error: 165_690 + .saturating_add(Weight::from_parts(55_174_777, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(11_u64)) .saturating_add(T::DbWeight::get().writes(9_u64)) .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(c.into()))) @@ -342,10 +472,10 @@ impl pallet_gear::WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `113` // Estimated: `5402` - // Minimum execution time: 78_662_000 picoseconds. - Weight::from_parts(42_066_175, 5402) - // Standard Error: 52_075 - .saturating_add(Weight::from_parts(60_249_549, 0).saturating_mul(c.into())) + // Minimum execution time: 79_739_000 picoseconds. + Weight::from_parts(1_118_426, 5402) + // Standard Error: 68_897 + .saturating_add(Weight::from_parts(60_115_395, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(4_u64)) } @@ -354,10 +484,10 @@ impl pallet_gear::WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `1111` // Estimated: `50600` - // Minimum execution time: 94_321_000 picoseconds. - Weight::from_parts(129_113_540, 50600) - // Standard Error: 1 - .saturating_add(Weight::from_parts(2_625, 0).saturating_mul(s.into())) + // Minimum execution time: 96_509_000 picoseconds. + Weight::from_parts(129_317_147, 50600) + // Standard Error: 0 + .saturating_add(Weight::from_parts(2_581, 0).saturating_mul(s.into())) .saturating_add(T::DbWeight::get().reads(15_u64)) .saturating_add(T::DbWeight::get().writes(12_u64)) } @@ -367,12 +497,12 @@ impl pallet_gear::WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `521` // Estimated: `45152` - // Minimum execution time: 11_148_491_000 picoseconds. - Weight::from_parts(21_065_971, 45152) - // Standard Error: 173_883 - .saturating_add(Weight::from_parts(60_839_567, 0).saturating_mul(c.into())) - // Standard Error: 10 - .saturating_add(Weight::from_parts(2_652, 0).saturating_mul(s.into())) + // Minimum execution time: 10_940_898_000 picoseconds. + Weight::from_parts(67_432_582, 45152) + // Standard Error: 159_611 + .saturating_add(Weight::from_parts(61_428_399, 0).saturating_mul(c.into())) + // Standard Error: 9 + .saturating_add(Weight::from_parts(2_577, 0).saturating_mul(s.into())) .saturating_add(T::DbWeight::get().reads(15_u64)) .saturating_add(T::DbWeight::get().writes(16_u64)) } @@ -381,10 +511,10 @@ impl pallet_gear::WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `531` // Estimated: `31266` - // Minimum execution time: 73_302_000 picoseconds. - Weight::from_parts(47_279_667, 31266) + // Minimum execution time: 77_245_000 picoseconds. + Weight::from_parts(59_204_735, 31266) // Standard Error: 1 - .saturating_add(Weight::from_parts(1_055, 0).saturating_mul(p.into())) + .saturating_add(Weight::from_parts(1_042, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads(11_u64)) .saturating_add(T::DbWeight::get().writes(10_u64)) } @@ -393,33 +523,33 @@ impl pallet_gear::WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `1371` // Estimated: `54435` - // Minimum execution time: 124_173_000 picoseconds. - Weight::from_parts(96_458_887, 54435) + // Minimum execution time: 128_271_000 picoseconds. + Weight::from_parts(93_877_619, 54435) // Standard Error: 2 - .saturating_add(Weight::from_parts(1_078, 0).saturating_mul(p.into())) + .saturating_add(Weight::from_parts(1_085, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads(16_u64)) .saturating_add(T::DbWeight::get().writes(13_u64)) } /// The range of component `q` is `[1, 512]`. fn initial_allocation(_q: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `1893` - // Estimated: `114612` - // Minimum execution time: 365_983_000 picoseconds. - Weight::from_parts(387_416_952, 114612) - .saturating_add(T::DbWeight::get().reads(33_u64)) + // Measured: `1897` + // Estimated: `121468` + // Minimum execution time: 379_776_000 picoseconds. + Weight::from_parts(397_994_052, 121468) + .saturating_add(T::DbWeight::get().reads(35_u64)) .saturating_add(T::DbWeight::get().writes(26_u64)) } /// The range of component `q` is `[0, 512]`. fn alloc_in_handle(q: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `1893` - // Estimated: `114612` - // Minimum execution time: 380_430_000 picoseconds. - Weight::from_parts(403_376_118, 114612) - // Standard Error: 2_451 - .saturating_add(Weight::from_parts(1_137, 0).saturating_mul(q.into())) - .saturating_add(T::DbWeight::get().reads(33_u64)) + // Measured: `1897` + // Estimated: `121468` + // Minimum execution time: 393_678_000 picoseconds. + Weight::from_parts(411_350_620, 121468) + // Standard Error: 1_741 + .saturating_add(Weight::from_parts(5_796, 0).saturating_mul(q.into())) + .saturating_add(T::DbWeight::get().reads(35_u64)) .saturating_add(T::DbWeight::get().writes(26_u64)) } /// The range of component `c` is `[0, 512]`. @@ -427,10 +557,10 @@ impl pallet_gear::WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `211 + c * (1075 ±0)` // Estimated: `3899 + c * (2150 ±0)` - // Minimum execution time: 58_080_000 picoseconds. - Weight::from_parts(58_601_000, 3899) - // Standard Error: 36_083 - .saturating_add(Weight::from_parts(58_395_643, 0).saturating_mul(c.into())) + // Minimum execution time: 58_693_000 picoseconds. + Weight::from_parts(59_295_000, 3899) + // Standard Error: 33_015 + .saturating_add(Weight::from_parts(61_659_744, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) .saturating_add(Weight::from_parts(0, 2150).saturating_mul(c.into())) @@ -440,638 +570,510 @@ impl pallet_gear::WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 91_412_000 picoseconds. - Weight::from_parts(94_168_000, 0) - // Standard Error: 3_806_298 - .saturating_add(Weight::from_parts(673_774_453, 0).saturating_mul(r.into())) + // Minimum execution time: 94_082_000 picoseconds. + Weight::from_parts(97_548_000, 0) + // Standard Error: 3_920_023 + .saturating_add(Weight::from_parts(729_307_729, 0).saturating_mul(r.into())) } /// The range of component `p` is `[1, 512]`. fn alloc_per_page(p: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 452_549_000 picoseconds. - Weight::from_parts(398_963_700, 0) - // Standard Error: 7_042 - .saturating_add(Weight::from_parts(29_406_609, 0).saturating_mul(p.into())) + // Minimum execution time: 491_508_000 picoseconds. + Weight::from_parts(463_051_109, 0) + // Standard Error: 421_338 + .saturating_add(Weight::from_parts(31_169_166, 0).saturating_mul(p.into())) } /// The range of component `r` is `[0, 20]`. fn free(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 207_052_000 picoseconds. - Weight::from_parts(209_606_478, 0) - // Standard Error: 255_281 - .saturating_add(Weight::from_parts(62_959_531, 0).saturating_mul(r.into())) + // Minimum execution time: 220_882_000 picoseconds. + Weight::from_parts(231_751_371, 0) + // Standard Error: 241_524 + .saturating_add(Weight::from_parts(62_988_026, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 256]`. fn gr_reserve_gas(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 97_729_000 picoseconds. - Weight::from_parts(105_964_750, 0) - // Standard Error: 4_847 - .saturating_add(Weight::from_parts(2_433_966, 0).saturating_mul(r.into())) + // Minimum execution time: 100_013_000 picoseconds. + Weight::from_parts(108_487_423, 0) + // Standard Error: 4_858 + .saturating_add(Weight::from_parts(2_524_407, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 256]`. fn gr_unreserve_gas(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 175_010_000 picoseconds. - Weight::from_parts(229_153_209, 0) - // Standard Error: 17_116 - .saturating_add(Weight::from_parts(1_991_260, 0).saturating_mul(r.into())) + // Minimum execution time: 182_206_000 picoseconds. + Weight::from_parts(218_782_104, 0) + // Standard Error: 14_768 + .saturating_add(Weight::from_parts(2_153_377, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_system_reserve_gas(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 94_696_000 picoseconds. - Weight::from_parts(119_674_535, 0) - // Standard Error: 387_178 - .saturating_add(Weight::from_parts(98_102_856, 0).saturating_mul(r.into())) + // Minimum execution time: 97_458_000 picoseconds. + Weight::from_parts(121_028_602, 0) + // Standard Error: 385_510 + .saturating_add(Weight::from_parts(95_782_527, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_message_id(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 95_794_000 picoseconds. - Weight::from_parts(89_931_979, 0) - // Standard Error: 371_349 - .saturating_add(Weight::from_parts(86_524_059, 0).saturating_mul(r.into())) + // Minimum execution time: 101_412_000 picoseconds. + Weight::from_parts(86_061_953, 0) + // Standard Error: 356_205 + .saturating_add(Weight::from_parts(87_923_229, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_program_id(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 97_924_000 picoseconds. - Weight::from_parts(84_041_201, 0) - // Standard Error: 327_841 - .saturating_add(Weight::from_parts(95_483_315, 0).saturating_mul(r.into())) + // Minimum execution time: 101_962_000 picoseconds. + Weight::from_parts(96_667_757, 0) + // Standard Error: 333_738 + .saturating_add(Weight::from_parts(84_955_970, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_source(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 97_122_000 picoseconds. - Weight::from_parts(86_789_268, 0) - // Standard Error: 353_259 - .saturating_add(Weight::from_parts(85_698_317, 0).saturating_mul(r.into())) + // Minimum execution time: 98_464_000 picoseconds. + Weight::from_parts(90_164_484, 0) + // Standard Error: 321_979 + .saturating_add(Weight::from_parts(85_647_809, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_value(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 94_821_000 picoseconds. - Weight::from_parts(92_694_130, 0) - // Standard Error: 340_146 - .saturating_add(Weight::from_parts(84_623_945, 0).saturating_mul(r.into())) + // Minimum execution time: 97_334_000 picoseconds. + Weight::from_parts(91_107_930, 0) + // Standard Error: 336_291 + .saturating_add(Weight::from_parts(85_501_563, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_value_available(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 93_840_000 picoseconds. - Weight::from_parts(87_888_572, 0) - // Standard Error: 369_465 - .saturating_add(Weight::from_parts(85_638_902, 0).saturating_mul(r.into())) + // Minimum execution time: 96_398_000 picoseconds. + Weight::from_parts(97_803_650, 0) + // Standard Error: 330_728 + .saturating_add(Weight::from_parts(84_746_249, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_gas_available(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 98_597_000 picoseconds. - Weight::from_parts(86_642_386, 0) - // Standard Error: 362_257 - .saturating_add(Weight::from_parts(85_598_887, 0).saturating_mul(r.into())) + // Minimum execution time: 99_554_000 picoseconds. + Weight::from_parts(77_927_782, 0) + // Standard Error: 386_800 + .saturating_add(Weight::from_parts(90_358_021, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_size(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 94_546_000 picoseconds. - Weight::from_parts(91_466_289, 0) - // Standard Error: 344_423 - .saturating_add(Weight::from_parts(84_318_848, 0).saturating_mul(r.into())) + // Minimum execution time: 102_554_000 picoseconds. + Weight::from_parts(96_055_722, 0) + // Standard Error: 331_628 + .saturating_add(Weight::from_parts(84_542_244, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_read(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 578_036_000 picoseconds. - Weight::from_parts(696_140_951, 0) - // Standard Error: 559_498 - .saturating_add(Weight::from_parts(149_397_501, 0).saturating_mul(r.into())) + // Minimum execution time: 725_792_000 picoseconds. + Weight::from_parts(801_544_878, 0) + // Standard Error: 398_821 + .saturating_add(Weight::from_parts(140_715_634, 0).saturating_mul(r.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_read_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 723_788_000 picoseconds. - Weight::from_parts(740_225_000, 0) - // Standard Error: 52_895 - .saturating_add(Weight::from_parts(13_188_120, 0).saturating_mul(n.into())) + // Minimum execution time: 869_816_000 picoseconds. + Weight::from_parts(886_588_000, 0) + // Standard Error: 54_300 + .saturating_add(Weight::from_parts(13_214_277, 0).saturating_mul(n.into())) } /// The range of component `r` is `[0, 20]`. fn gr_block_height(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 99_012_000 picoseconds. - Weight::from_parts(88_269_135, 0) - // Standard Error: 296_136 - .saturating_add(Weight::from_parts(92_296_104, 0).saturating_mul(r.into())) + // Minimum execution time: 98_800_000 picoseconds. + Weight::from_parts(92_344_333, 0) + // Standard Error: 339_355 + .saturating_add(Weight::from_parts(86_790_706, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_block_timestamp(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 93_803_000 picoseconds. - Weight::from_parts(87_097_769, 0) - // Standard Error: 367_325 - .saturating_add(Weight::from_parts(84_987_043, 0).saturating_mul(r.into())) + // Minimum execution time: 97_651_000 picoseconds. + Weight::from_parts(92_529_847, 0) + // Standard Error: 295_105 + .saturating_add(Weight::from_parts(89_002_384, 0).saturating_mul(r.into())) } /// The range of component `n` is `[0, 20]`. fn gr_random(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 96_663_000 picoseconds. - Weight::from_parts(105_357_427, 0) - // Standard Error: 366_135 - .saturating_add(Weight::from_parts(172_109_201, 0).saturating_mul(n.into())) + // Minimum execution time: 99_357_000 picoseconds. + Weight::from_parts(105_767_963, 0) + // Standard Error: 380_641 + .saturating_add(Weight::from_parts(174_604_231, 0).saturating_mul(n.into())) } /// The range of component `r` is `[0, 20]`. fn gr_reply_deposit(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 99_210_000 picoseconds. - Weight::from_parts(102_217_000, 0) - // Standard Error: 4_527_119 - .saturating_add(Weight::from_parts(845_784_967, 0).saturating_mul(r.into())) + // Minimum execution time: 103_092_000 picoseconds. + Weight::from_parts(105_802_000, 0) + // Standard Error: 3_553_393 + .saturating_add(Weight::from_parts(783_848_741, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_send(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 96_579_000 picoseconds. - Weight::from_parts(162_452_429, 0) - // Standard Error: 416_836 - .saturating_add(Weight::from_parts(257_900_517, 0).saturating_mul(r.into())) + // Minimum execution time: 97_050_000 picoseconds. + Weight::from_parts(174_923_994, 0) + // Standard Error: 430_038 + .saturating_add(Weight::from_parts(266_665_269, 0).saturating_mul(r.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_send_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 353_526_000 picoseconds. - Weight::from_parts(358_025_000, 0) - // Standard Error: 61_984 - .saturating_add(Weight::from_parts(21_521_461, 0).saturating_mul(n.into())) + // Minimum execution time: 357_531_000 picoseconds. + Weight::from_parts(365_896_000, 0) + // Standard Error: 59_017 + .saturating_add(Weight::from_parts(21_340_532, 0).saturating_mul(n.into())) } /// The range of component `r` is `[0, 20]`. fn gr_send_wgas(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 94_822_000 picoseconds. - Weight::from_parts(168_431_611, 0) - // Standard Error: 378_696 - .saturating_add(Weight::from_parts(263_135_958, 0).saturating_mul(r.into())) + // Minimum execution time: 98_643_000 picoseconds. + Weight::from_parts(185_395_839, 0) + // Standard Error: 402_403 + .saturating_add(Weight::from_parts(266_083_111, 0).saturating_mul(r.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_send_wgas_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 351_828_000 picoseconds. - Weight::from_parts(355_382_000, 0) - // Standard Error: 60_589 - .saturating_add(Weight::from_parts(21_325_400, 0).saturating_mul(n.into())) + // Minimum execution time: 361_853_000 picoseconds. + Weight::from_parts(371_175_000, 0) + // Standard Error: 62_531 + .saturating_add(Weight::from_parts(21_372_225, 0).saturating_mul(n.into())) } /// The range of component `r` is `[0, 20]`. fn gr_send_input(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 569_384_000 picoseconds. - Weight::from_parts(638_474_730, 0) - // Standard Error: 425_903 - .saturating_add(Weight::from_parts(275_691_711, 0).saturating_mul(r.into())) + // Minimum execution time: 731_246_000 picoseconds. + Weight::from_parts(827_016_024, 0) + // Standard Error: 456_568 + .saturating_add(Weight::from_parts(283_568_931, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_send_input_wgas(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 573_053_000 picoseconds. - Weight::from_parts(640_078_802, 0) - // Standard Error: 475_389 - .saturating_add(Weight::from_parts(284_337_155, 0).saturating_mul(r.into())) + // Minimum execution time: 725_315_000 picoseconds. + Weight::from_parts(814_525_892, 0) + // Standard Error: 535_531 + .saturating_add(Weight::from_parts(291_725_582, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_send_init(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 98_223_000 picoseconds. - Weight::from_parts(85_732_985, 0) - // Standard Error: 336_308 - .saturating_add(Weight::from_parts(92_936_006, 0).saturating_mul(r.into())) + // Minimum execution time: 100_930_000 picoseconds. + Weight::from_parts(86_911_409, 0) + // Standard Error: 308_962 + .saturating_add(Weight::from_parts(98_197_967, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_send_push(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_822_621_000 picoseconds. - Weight::from_parts(1_951_955_018, 0) - // Standard Error: 339_415 - .saturating_add(Weight::from_parts(157_557_756, 0).saturating_mul(r.into())) + // Minimum execution time: 1_871_002_000 picoseconds. + Weight::from_parts(2_023_643_652, 0) + // Standard Error: 354_203 + .saturating_add(Weight::from_parts(163_033_723, 0).saturating_mul(r.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_send_push_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 314_296_000 picoseconds. - Weight::from_parts(317_522_000, 0) - // Standard Error: 61_360 - .saturating_add(Weight::from_parts(29_499_741, 0).saturating_mul(n.into())) + // Minimum execution time: 321_280_000 picoseconds. + Weight::from_parts(326_774_000, 0) + // Standard Error: 53_820 + .saturating_add(Weight::from_parts(31_205_219, 0).saturating_mul(n.into())) } /// The range of component `r` is `[0, 20]`. fn gr_send_commit(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_835_106_000 picoseconds. - Weight::from_parts(1_948_516_646, 0) - // Standard Error: 382_008 - .saturating_add(Weight::from_parts(214_812_508, 0).saturating_mul(r.into())) + // Minimum execution time: 1_866_780_000 picoseconds. + Weight::from_parts(2_024_271_501, 0) + // Standard Error: 405_972 + .saturating_add(Weight::from_parts(225_776_414, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_send_commit_wgas(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_827_496_000 picoseconds. - Weight::from_parts(1_949_190_773, 0) - // Standard Error: 340_175 - .saturating_add(Weight::from_parts(218_001_536, 0).saturating_mul(r.into())) + // Minimum execution time: 1_875_608_000 picoseconds. + Weight::from_parts(2_019_090_196, 0) + // Standard Error: 346_810 + .saturating_add(Weight::from_parts(235_898_569, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_reservation_send(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 264_306_000 picoseconds. - Weight::from_parts(363_536_651, 0) - // Standard Error: 467_914 - .saturating_add(Weight::from_parts(265_564_072, 0).saturating_mul(r.into())) + // Minimum execution time: 263_903_000 picoseconds. + Weight::from_parts(339_925_241, 0) + // Standard Error: 414_003 + .saturating_add(Weight::from_parts(280_423_422, 0).saturating_mul(r.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_reservation_send_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 523_150_000 picoseconds. - Weight::from_parts(535_842_000, 0) - // Standard Error: 65_412 - .saturating_add(Weight::from_parts(21_698_063, 0).saturating_mul(n.into())) + // Minimum execution time: 535_212_000 picoseconds. + Weight::from_parts(545_222_000, 0) + // Standard Error: 58_250 + .saturating_add(Weight::from_parts(21_556_762, 0).saturating_mul(n.into())) } /// The range of component `r` is `[0, 20]`. fn gr_reservation_send_commit(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_974_743_000 picoseconds. - Weight::from_parts(2_096_494_995, 0) - // Standard Error: 474_778 - .saturating_add(Weight::from_parts(232_524_299, 0).saturating_mul(r.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_reply(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 94_139_000 picoseconds. - Weight::from_parts(101_775_569, 0) - // Standard Error: 452_439 - .saturating_add(Weight::from_parts(16_839_430, 0).saturating_mul(r.into())) + // Minimum execution time: 2_022_436_000 picoseconds. + Weight::from_parts(2_212_258_384, 0) + // Standard Error: 460_291 + .saturating_add(Weight::from_parts(249_403_133, 0).saturating_mul(r.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_reply_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 112_050_000 picoseconds. - Weight::from_parts(102_205_366, 0) - // Standard Error: 1_008 - .saturating_add(Weight::from_parts(431_304, 0).saturating_mul(n.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_reply_wgas(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 93_528_000 picoseconds. - Weight::from_parts(99_748_422, 0) - // Standard Error: 396_992 - .saturating_add(Weight::from_parts(20_536_877, 0).saturating_mul(r.into())) + // Minimum execution time: 117_080_000 picoseconds. + Weight::from_parts(104_765_276, 0) + // Standard Error: 994 + .saturating_add(Weight::from_parts(436_761, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_reply_wgas_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 117_832_000 picoseconds. - Weight::from_parts(104_552_847, 0) - // Standard Error: 1_402 - .saturating_add(Weight::from_parts(432_018, 0).saturating_mul(n.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_reply_commit(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 93_325_000 picoseconds. - Weight::from_parts(101_074_097, 0) - // Standard Error: 454_790 - .saturating_add(Weight::from_parts(20_838_102, 0).saturating_mul(r.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_reply_commit_wgas(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 93_800_000 picoseconds. - Weight::from_parts(102_249_326, 0) - // Standard Error: 463_488 - .saturating_add(Weight::from_parts(15_991_473, 0).saturating_mul(r.into())) + // Minimum execution time: 115_283_000 picoseconds. + Weight::from_parts(109_185_112, 0) + // Standard Error: 1_244 + .saturating_add(Weight::from_parts(432_177, 0).saturating_mul(n.into())) } /// The range of component `r` is `[0, 20]`. fn gr_reply_push(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 93_153_000 picoseconds. - Weight::from_parts(121_452_989, 0) - // Standard Error: 390_540 - .saturating_add(Weight::from_parts(145_641_178, 0).saturating_mul(r.into())) + // Minimum execution time: 97_873_000 picoseconds. + Weight::from_parts(159_110_710, 0) + // Standard Error: 457_822 + .saturating_add(Weight::from_parts(152_162_507, 0).saturating_mul(r.into())) } /// The range of component `n` is `[0, 8192]`. fn gr_reply_push_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 115_529_000 picoseconds. - Weight::from_parts(120_413_000, 0) - // Standard Error: 3_105 - .saturating_add(Weight::from_parts(640_863, 0).saturating_mul(n.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_reply_input(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 566_859_000 picoseconds. - Weight::from_parts(631_111_316, 0) - // Standard Error: 7_012_228 - .saturating_add(Weight::from_parts(21_896_983, 0).saturating_mul(r.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_reply_input_wgas(_r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 565_382_000 picoseconds. - Weight::from_parts(613_048_008, 0) - } - /// The range of component `r` is `[0, 1]`. - fn gr_reservation_reply(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 104_401_000 picoseconds. - Weight::from_parts(112_651_320, 0) - // Standard Error: 438_590 - .saturating_add(Weight::from_parts(11_095_379, 0).saturating_mul(r.into())) + // Minimum execution time: 112_593_000 picoseconds. + Weight::from_parts(114_913_000, 0) + // Standard Error: 2_557 + .saturating_add(Weight::from_parts(677_985, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_reservation_reply_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 115_615_000 picoseconds. - Weight::from_parts(112_987_750, 0) - // Standard Error: 960 - .saturating_add(Weight::from_parts(423_774, 0).saturating_mul(n.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_reservation_reply_commit(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 105_056_000 picoseconds. - Weight::from_parts(113_735_922, 0) - // Standard Error: 466_586 - .saturating_add(Weight::from_parts(5_305_577, 0).saturating_mul(r.into())) + // Minimum execution time: 118_073_000 picoseconds. + Weight::from_parts(113_763_795, 0) + // Standard Error: 1_010 + .saturating_add(Weight::from_parts(428_786, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_reservation_reply_commit_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 113_897_000 picoseconds. - Weight::from_parts(112_616_408, 0) - // Standard Error: 1_722 - .saturating_add(Weight::from_parts(428_420, 0).saturating_mul(n.into())) + // Minimum execution time: 114_860_000 picoseconds. + Weight::from_parts(101_920_439, 0) + // Standard Error: 1_083 + .saturating_add(Weight::from_parts(442_833, 0).saturating_mul(n.into())) } /// The range of component `r` is `[0, 20]`. fn gr_reply_to(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 93_845_000 picoseconds. - Weight::from_parts(97_247_314, 0) - // Standard Error: 366_814 - .saturating_add(Weight::from_parts(85_900_587, 0).saturating_mul(r.into())) + // Minimum execution time: 98_512_000 picoseconds. + Weight::from_parts(88_626_388, 0) + // Standard Error: 366_499 + .saturating_add(Weight::from_parts(88_122_315, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_signal_code(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 99_671_000 picoseconds. - Weight::from_parts(92_224_076, 0) - // Standard Error: 324_122 - .saturating_add(Weight::from_parts(85_769_450, 0).saturating_mul(r.into())) + // Minimum execution time: 100_944_000 picoseconds. + Weight::from_parts(94_274_573, 0) + // Standard Error: 344_379 + .saturating_add(Weight::from_parts(83_385_159, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_signal_from(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 100_099_000 picoseconds. - Weight::from_parts(93_778_262, 0) - // Standard Error: 323_481 - .saturating_add(Weight::from_parts(87_801_615, 0).saturating_mul(r.into())) + // Minimum execution time: 98_736_000 picoseconds. + Weight::from_parts(102_598_887, 0) + // Standard Error: 254_019 + .saturating_add(Weight::from_parts(86_050_309, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_reply_push_input(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 565_388_000 picoseconds. - Weight::from_parts(606_358_854, 0) - // Standard Error: 430_766 - .saturating_add(Weight::from_parts(108_769_267, 0).saturating_mul(r.into())) + // Minimum execution time: 740_156_000 picoseconds. + Weight::from_parts(781_820_116, 0) + // Standard Error: 419_407 + .saturating_add(Weight::from_parts(107_969_773, 0).saturating_mul(r.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_reply_push_input_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 591_660_000 picoseconds. - Weight::from_parts(597_035_528, 0) - // Standard Error: 2_641 - .saturating_add(Weight::from_parts(153_781, 0).saturating_mul(n.into())) + // Minimum execution time: 755_846_000 picoseconds. + Weight::from_parts(780_455_697, 0) + // Standard Error: 1_995 + .saturating_add(Weight::from_parts(161_261, 0).saturating_mul(n.into())) } /// The range of component `r` is `[0, 20]`. fn gr_send_push_input(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_317_147_000 picoseconds. - Weight::from_parts(2_514_940_964, 0) - // Standard Error: 546_319 - .saturating_add(Weight::from_parts(128_825_542, 0).saturating_mul(r.into())) + // Minimum execution time: 2_511_608_000 picoseconds. + Weight::from_parts(2_705_076_651, 0) + // Standard Error: 493_983 + .saturating_add(Weight::from_parts(127_194_997, 0).saturating_mul(r.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_send_push_input_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_560_344_000 picoseconds. - Weight::from_parts(2_512_409_449, 0) - // Standard Error: 15_466 - .saturating_add(Weight::from_parts(12_395_144, 0).saturating_mul(n.into())) + // Minimum execution time: 2_717_264_000 picoseconds. + Weight::from_parts(2_814_539_958, 0) + // Standard Error: 10_103 + .saturating_add(Weight::from_parts(13_630_637, 0).saturating_mul(n.into())) } /// The range of component `r` is `[0, 20]`. fn gr_debug(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 97_996_000 picoseconds. - Weight::from_parts(130_630_238, 0) - // Standard Error: 414_418 - .saturating_add(Weight::from_parts(114_735_577, 0).saturating_mul(r.into())) + // Minimum execution time: 97_818_000 picoseconds. + Weight::from_parts(112_676_264, 0) + // Standard Error: 333_130 + .saturating_add(Weight::from_parts(114_231_920, 0).saturating_mul(r.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_debug_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 157_513_000 picoseconds. - Weight::from_parts(160_584_000, 0) - // Standard Error: 57_227 - .saturating_add(Weight::from_parts(25_738_939, 0).saturating_mul(n.into())) + // Minimum execution time: 159_849_000 picoseconds. + Weight::from_parts(161_376_000, 0) + // Standard Error: 52_546 + .saturating_add(Weight::from_parts(25_816_075, 0).saturating_mul(n.into())) } /// The range of component `r` is `[0, 20]`. fn gr_reply_code(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 92_652_000 picoseconds. - Weight::from_parts(88_138_429, 0) - // Standard Error: 330_537 - .saturating_add(Weight::from_parts(83_235_234, 0).saturating_mul(r.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_exit(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 93_824_000 picoseconds. - Weight::from_parts(102_740_497, 0) - // Standard Error: 428_593 - .saturating_add(Weight::from_parts(23_682_102, 0).saturating_mul(r.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_leave(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 92_530_000 picoseconds. - Weight::from_parts(101_410_861, 0) - // Standard Error: 432_236 - .saturating_add(Weight::from_parts(12_196_938, 0).saturating_mul(r.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_wait(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 93_402_000 picoseconds. - Weight::from_parts(102_285_877, 0) - // Standard Error: 466_463 - .saturating_add(Weight::from_parts(13_156_522, 0).saturating_mul(r.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_wait_for(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 95_706_000 picoseconds. - Weight::from_parts(102_513_059, 0) - // Standard Error: 464_787 - .saturating_add(Weight::from_parts(13_986_540, 0).saturating_mul(r.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_wait_up_to(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 93_057_000 picoseconds. - Weight::from_parts(99_083_869, 0) - // Standard Error: 378_747 - .saturating_add(Weight::from_parts(12_230_330, 0).saturating_mul(r.into())) + // Minimum execution time: 98_916_000 picoseconds. + Weight::from_parts(92_228_268, 0) + // Standard Error: 329_307 + .saturating_add(Weight::from_parts(83_076_033, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_wake(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 177_947_000 picoseconds. - Weight::from_parts(226_692_243, 0) - // Standard Error: 265_725 - .saturating_add(Weight::from_parts(156_938_838, 0).saturating_mul(r.into())) + // Minimum execution time: 179_446_000 picoseconds. + Weight::from_parts(229_514_451, 0) + // Standard Error: 257_645 + .saturating_add(Weight::from_parts(154_731_264, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_create_program(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 107_346_000 picoseconds. - Weight::from_parts(160_631_540, 0) - // Standard Error: 352_753 - .saturating_add(Weight::from_parts(338_685_448, 0).saturating_mul(r.into())) + // Minimum execution time: 107_616_000 picoseconds. + Weight::from_parts(175_768_720, 0) + // Standard Error: 367_635 + .saturating_add(Weight::from_parts(358_564_932, 0).saturating_mul(r.into())) } /// The range of component `p` is `[0, 2048]`. /// The range of component `s` is `[1, 2048]`. @@ -1079,22 +1081,22 @@ impl pallet_gear::WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 44_754_074_000 picoseconds. - Weight::from_parts(44_833_050_000, 0) - // Standard Error: 269_308 - .saturating_add(Weight::from_parts(7_629_892, 0).saturating_mul(p.into())) - // Standard Error: 269_294 - .saturating_add(Weight::from_parts(179_148_245, 0).saturating_mul(s.into())) + // Minimum execution time: 44_902_420_000 picoseconds. + Weight::from_parts(45_126_501_000, 0) + // Standard Error: 280_708 + .saturating_add(Weight::from_parts(7_774_529, 0).saturating_mul(p.into())) + // Standard Error: 280_694 + .saturating_add(Weight::from_parts(175_731_776, 0).saturating_mul(s.into())) } /// The range of component `r` is `[0, 20]`. fn gr_create_program_wgas(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 108_278_000 picoseconds. - Weight::from_parts(161_208_126, 0) - // Standard Error: 368_644 - .saturating_add(Weight::from_parts(346_324_329, 0).saturating_mul(r.into())) + // Minimum execution time: 108_285_000 picoseconds. + Weight::from_parts(176_429_268, 0) + // Standard Error: 384_072 + .saturating_add(Weight::from_parts(366_592_077, 0).saturating_mul(r.into())) } /// The range of component `p` is `[0, 2048]`. /// The range of component `s` is `[1, 2048]`. @@ -1102,32 +1104,32 @@ impl pallet_gear::WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 44_266_209_000 picoseconds. - Weight::from_parts(44_559_345_000, 0) - // Standard Error: 270_420 - .saturating_add(Weight::from_parts(7_460_172, 0).saturating_mul(p.into())) - // Standard Error: 270_407 - .saturating_add(Weight::from_parts(179_211_260, 0).saturating_mul(s.into())) + // Minimum execution time: 46_638_288_000 picoseconds. + Weight::from_parts(47_081_319_000, 0) + // Standard Error: 280_733 + .saturating_add(Weight::from_parts(7_134_527, 0).saturating_mul(p.into())) + // Standard Error: 280_720 + .saturating_add(Weight::from_parts(175_082_854, 0).saturating_mul(s.into())) } /// The range of component `r` is `[0, 20]`. fn gr_pay_program_rent(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 94_889_000 picoseconds. - Weight::from_parts(115_310_524, 0) - // Standard Error: 34_049 - .saturating_add(Weight::from_parts(1_916_607, 0).saturating_mul(r.into())) + // Minimum execution time: 100_230_000 picoseconds. + Weight::from_parts(120_175_562, 0) + // Standard Error: 35_806 + .saturating_add(Weight::from_parts(1_783_612, 0).saturating_mul(r.into())) } /// The range of component `p` is `[0, 512]`. fn lazy_pages_signal_read(p: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `141` // Estimated: `1131 + p * (9900 ±0)` - // Minimum execution time: 97_825_000 picoseconds. - Weight::from_parts(251_440_245, 1131) - // Standard Error: 70_641 - .saturating_add(Weight::from_parts(15_652_952, 0).saturating_mul(p.into())) + // Minimum execution time: 99_162_000 picoseconds. + Weight::from_parts(112_460_979, 1131) + // Standard Error: 19_215 + .saturating_add(Weight::from_parts(16_485_170, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads((4_u64).saturating_mul(p.into()))) .saturating_add(Weight::from_parts(0, 9900).saturating_mul(p.into())) } @@ -1136,10 +1138,10 @@ impl pallet_gear::WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `141` // Estimated: `1131 + p * (9900 ±0)` - // Minimum execution time: 96_761_000 picoseconds. - Weight::from_parts(100_398_000, 1131) - // Standard Error: 45_532 - .saturating_add(Weight::from_parts(39_790_625, 0).saturating_mul(p.into())) + // Minimum execution time: 100_684_000 picoseconds. + Weight::from_parts(104_531_000, 1131) + // Standard Error: 46_782 + .saturating_add(Weight::from_parts(42_067_142, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads((4_u64).saturating_mul(p.into()))) .saturating_add(Weight::from_parts(0, 9900).saturating_mul(p.into())) } @@ -1148,10 +1150,10 @@ impl pallet_gear::WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `141` // Estimated: `5069931` - // Minimum execution time: 7_471_807_000 picoseconds. - Weight::from_parts(7_440_591_962, 5069931) - // Standard Error: 168_373 - .saturating_add(Weight::from_parts(40_244_359, 0).saturating_mul(p.into())) + // Minimum execution time: 8_272_424_000 picoseconds. + Weight::from_parts(8_390_589_661, 5069931) + // Standard Error: 72_393 + .saturating_add(Weight::from_parts(42_604_682, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads(2048_u64)) } /// The range of component `p` is `[0, 512]`. @@ -1159,10 +1161,10 @@ impl pallet_gear::WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `1813 + p * (65580 ±0)` // Estimated: `1939 + p * (75482 ±0)` - // Minimum execution time: 97_303_000 picoseconds. - Weight::from_parts(98_185_000, 1939) - // Standard Error: 38_471 - .saturating_add(Weight::from_parts(55_016_921, 0).saturating_mul(p.into())) + // Minimum execution time: 105_024_000 picoseconds. + Weight::from_parts(106_386_000, 1939) + // Standard Error: 32_440 + .saturating_add(Weight::from_parts(54_183_902, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads((4_u64).saturating_mul(p.into()))) .saturating_add(Weight::from_parts(0, 75482).saturating_mul(p.into())) } @@ -1171,10 +1173,10 @@ impl pallet_gear::WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `141` // Estimated: `1131 + p * (9900 ±0)` - // Minimum execution time: 102_497_000 picoseconds. - Weight::from_parts(104_932_685, 1131) - // Standard Error: 78_974 - .saturating_add(Weight::from_parts(39_257_150, 0).saturating_mul(p.into())) + // Minimum execution time: 102_854_000 picoseconds. + Weight::from_parts(109_646_367, 1131) + // Standard Error: 70_655 + .saturating_add(Weight::from_parts(39_228_760, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads((4_u64).saturating_mul(p.into()))) .saturating_add(Weight::from_parts(0, 9900).saturating_mul(p.into())) } @@ -1183,10 +1185,10 @@ impl pallet_gear::WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `141` // Estimated: `1496 + p * (9883 ±2)` - // Minimum execution time: 612_308_000 picoseconds. - Weight::from_parts(642_079_999, 1496) - // Standard Error: 357_245 - .saturating_add(Weight::from_parts(46_518_860, 0).saturating_mul(p.into())) + // Minimum execution time: 761_606_000 picoseconds. + Weight::from_parts(762_350_763, 1496) + // Standard Error: 286_780 + .saturating_add(Weight::from_parts(50_979_584, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads((4_u64).saturating_mul(p.into()))) .saturating_add(Weight::from_parts(0, 9883).saturating_mul(p.into())) } @@ -1195,10 +1197,10 @@ impl pallet_gear::WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `141` // Estimated: `317931` - // Minimum execution time: 1_068_248_000 picoseconds. - Weight::from_parts(1_080_741_205, 317931) - // Standard Error: 262_216 - .saturating_add(Weight::from_parts(50_047_907, 0).saturating_mul(p.into())) + // Minimum execution time: 1_256_343_000 picoseconds. + Weight::from_parts(1_302_047_252, 317931) + // Standard Error: 283_008 + .saturating_add(Weight::from_parts(47_678_236, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads(128_u64)) } /// The range of component `r` is `[0, 20]`. @@ -1206,603 +1208,603 @@ impl pallet_gear::WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 3_099_000 picoseconds. - Weight::from_parts(6_340_084, 0) - // Standard Error: 180_257 - .saturating_add(Weight::from_parts(74_666_091, 0).saturating_mul(r.into())) + // Minimum execution time: 4_405_000 picoseconds. + Weight::from_parts(16_352_957, 0) + // Standard Error: 351_237 + .saturating_add(Weight::from_parts(74_154_815, 0).saturating_mul(r.into())) } /// The range of component `r` is `[50, 500]`. fn instr_i64load(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 4_391_547_000 picoseconds. - Weight::from_parts(4_140_785_425, 0) - // Standard Error: 89_369 - .saturating_add(Weight::from_parts(5_769_622, 0).saturating_mul(r.into())) + // Minimum execution time: 4_441_407_000 picoseconds. + Weight::from_parts(4_242_069_387, 0) + // Standard Error: 107_408 + .saturating_add(Weight::from_parts(5_267_383, 0).saturating_mul(r.into())) } /// The range of component `r` is `[50, 500]`. fn instr_i32load(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 4_386_802_000 picoseconds. - Weight::from_parts(4_243_536_456, 0) - // Standard Error: 95_210 - .saturating_add(Weight::from_parts(5_278_131, 0).saturating_mul(r.into())) + // Minimum execution time: 4_473_808_000 picoseconds. + Weight::from_parts(4_245_461_153, 0) + // Standard Error: 115_662 + .saturating_add(Weight::from_parts(5_334_771, 0).saturating_mul(r.into())) } /// The range of component `r` is `[50, 500]`. fn instr_i64store(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 11_072_272_000 picoseconds. - Weight::from_parts(11_558_306_225, 0) - // Standard Error: 165_659 - .saturating_add(Weight::from_parts(9_828_260, 0).saturating_mul(r.into())) + // Minimum execution time: 11_011_360_000 picoseconds. + Weight::from_parts(11_931_421_315, 0) + // Standard Error: 187_701 + .saturating_add(Weight::from_parts(13_022_743, 0).saturating_mul(r.into())) } /// The range of component `r` is `[50, 500]`. fn instr_i32store(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 10_285_071_000 picoseconds. - Weight::from_parts(11_137_621_942, 0) - // Standard Error: 147_513 - .saturating_add(Weight::from_parts(9_014_757, 0).saturating_mul(r.into())) + // Minimum execution time: 10_664_214_000 picoseconds. + Weight::from_parts(11_902_396_905, 0) + // Standard Error: 182_715 + .saturating_add(Weight::from_parts(10_825_224, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_select(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_285_000 picoseconds. - Weight::from_parts(2_410_000, 0) - // Standard Error: 7_624 - .saturating_add(Weight::from_parts(3_864_490, 0).saturating_mul(r.into())) + // Minimum execution time: 2_372_000 picoseconds. + Weight::from_parts(2_477_000, 0) + // Standard Error: 7_020 + .saturating_add(Weight::from_parts(3_847_128, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_if(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_342_000 picoseconds. - Weight::from_parts(2_433_000, 0) - // Standard Error: 6_413 - .saturating_add(Weight::from_parts(3_120_732, 0).saturating_mul(r.into())) + // Minimum execution time: 2_352_000 picoseconds. + Weight::from_parts(470_151, 0) + // Standard Error: 9_768 + .saturating_add(Weight::from_parts(3_187_107, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_br(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_301_000 picoseconds. - Weight::from_parts(3_591_730, 0) - // Standard Error: 1_106 - .saturating_add(Weight::from_parts(1_565_415, 0).saturating_mul(r.into())) + // Minimum execution time: 2_328_000 picoseconds. + Weight::from_parts(3_603_744, 0) + // Standard Error: 1_310 + .saturating_add(Weight::from_parts(1_573_794, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_br_if(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_306_000 picoseconds. - Weight::from_parts(2_461_000, 0) - // Standard Error: 7_711 - .saturating_add(Weight::from_parts(2_932_880, 0).saturating_mul(r.into())) + // Minimum execution time: 2_406_000 picoseconds. + Weight::from_parts(2_502_000, 0) + // Standard Error: 9_218 + .saturating_add(Weight::from_parts(2_948_836, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_br_table(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_358_000 picoseconds. - Weight::from_parts(2_144_801, 0) - // Standard Error: 22_082 - .saturating_add(Weight::from_parts(5_266_139, 0).saturating_mul(r.into())) + // Minimum execution time: 2_377_000 picoseconds. + Weight::from_parts(5_774_753, 0) + // Standard Error: 20_000 + .saturating_add(Weight::from_parts(4_967_379, 0).saturating_mul(r.into())) } /// The range of component `e` is `[1, 256]`. fn instr_br_table_per_entry(e: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 6_803_000 picoseconds. - Weight::from_parts(5_374_690, 0) - // Standard Error: 1_699 - .saturating_add(Weight::from_parts(171_193, 0).saturating_mul(e.into())) + // Minimum execution time: 7_031_000 picoseconds. + Weight::from_parts(5_288_626, 0) + // Standard Error: 1_512 + .saturating_add(Weight::from_parts(180_398, 0).saturating_mul(e.into())) } /// The range of component `r` is `[0, 50]`. fn instr_call_const(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_431_000 picoseconds. - Weight::from_parts(4_875_813, 0) - // Standard Error: 8_258 - .saturating_add(Weight::from_parts(2_629_733, 0).saturating_mul(r.into())) + // Minimum execution time: 2_476_000 picoseconds. + Weight::from_parts(5_743_941, 0) + // Standard Error: 9_413 + .saturating_add(Weight::from_parts(2_620_325, 0).saturating_mul(r.into())) } fn instr_i64const(r: u32, ) -> Weight { Weight::from_parts(0, 0) - .saturating_add(Weight::from_parts(2_629_733 - - 2_421_700, 0).saturating_mul(r.into())) + .saturating_add(Weight::from_parts(2_620_325 - + 2_411_747, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_call(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_403_000 picoseconds. - Weight::from_parts(5_140_243, 0) - // Standard Error: 13_164 - .saturating_add(Weight::from_parts(2_421_700, 0).saturating_mul(r.into())) + // Minimum execution time: 2_490_000 picoseconds. + Weight::from_parts(6_164_933, 0) + // Standard Error: 13_627 + .saturating_add(Weight::from_parts(2_411_747, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_call_indirect(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_669_000 picoseconds. - Weight::from_parts(22_369_265, 0) - // Standard Error: 28_577 - .saturating_add(Weight::from_parts(9_740_558, 0).saturating_mul(r.into())) + // Minimum execution time: 2_755_000 picoseconds. + Weight::from_parts(21_073_006, 0) + // Standard Error: 27_772 + .saturating_add(Weight::from_parts(9_843_221, 0).saturating_mul(r.into())) } /// The range of component `p` is `[0, 128]`. fn instr_call_indirect_per_param(p: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 12_277_000 picoseconds. - Weight::from_parts(3_596_853, 0) - // Standard Error: 5_869 - .saturating_add(Weight::from_parts(1_258_605, 0).saturating_mul(p.into())) + // Minimum execution time: 12_641_000 picoseconds. + Weight::from_parts(3_862_091, 0) + // Standard Error: 6_388 + .saturating_add(Weight::from_parts(1_271_540, 0).saturating_mul(p.into())) } /// The range of component `l` is `[0, 1024]`. fn instr_call_per_local(_l: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 5_391_000 picoseconds. - Weight::from_parts(5_778_137, 0) + // Minimum execution time: 5_445_000 picoseconds. + Weight::from_parts(5_936_643, 0) } /// The range of component `r` is `[0, 50]`. fn instr_local_get(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 4_835_000 picoseconds. - Weight::from_parts(6_065_483, 0) - // Standard Error: 3_006 - .saturating_add(Weight::from_parts(378_512, 0).saturating_mul(r.into())) + // Minimum execution time: 4_780_000 picoseconds. + Weight::from_parts(5_168_488, 0) + // Standard Error: 3_624 + .saturating_add(Weight::from_parts(434_517, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_local_set(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 4_722_000 picoseconds. - Weight::from_parts(3_902_309, 0) - // Standard Error: 5_742 - .saturating_add(Weight::from_parts(1_056_408, 0).saturating_mul(r.into())) + // Minimum execution time: 4_903_000 picoseconds. + Weight::from_parts(4_238_955, 0) + // Standard Error: 7_038 + .saturating_add(Weight::from_parts(1_087_596, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_local_tee(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 4_888_000 picoseconds. - Weight::from_parts(4_512_058, 0) - // Standard Error: 6_410 - .saturating_add(Weight::from_parts(1_001_510, 0).saturating_mul(r.into())) + // Minimum execution time: 4_937_000 picoseconds. + Weight::from_parts(3_461_941, 0) + // Standard Error: 7_961 + .saturating_add(Weight::from_parts(1_107_695, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_global_get(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 6_413_000 picoseconds. - Weight::from_parts(2_704_134, 0) - // Standard Error: 7_244 - .saturating_add(Weight::from_parts(804_200, 0).saturating_mul(r.into())) + // Minimum execution time: 6_601_000 picoseconds. + Weight::from_parts(2_918_352, 0) + // Standard Error: 7_206 + .saturating_add(Weight::from_parts(827_628, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_global_set(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 6_516_000 picoseconds. - Weight::from_parts(1_028_752, 0) - // Standard Error: 8_792 - .saturating_add(Weight::from_parts(1_494_630, 0).saturating_mul(r.into())) + // Minimum execution time: 6_605_000 picoseconds. + Weight::from_parts(6_684_000, 0) + // Standard Error: 8_000 + .saturating_add(Weight::from_parts(1_428_490, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_memory_current(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 5_560_000 picoseconds. - Weight::from_parts(1_126_442, 0) - // Standard Error: 14_476 - .saturating_add(Weight::from_parts(7_240_597, 0).saturating_mul(r.into())) + // Minimum execution time: 7_591_000 picoseconds. + Weight::from_parts(2_772_486, 0) + // Standard Error: 13_130 + .saturating_add(Weight::from_parts(7_127_049, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64clz(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_299_000 picoseconds. - Weight::from_parts(2_449_000, 0) - // Standard Error: 7_416 - .saturating_add(Weight::from_parts(3_344_387, 0).saturating_mul(r.into())) + // Minimum execution time: 2_376_000 picoseconds. + Weight::from_parts(2_431_000, 0) + // Standard Error: 6_471 + .saturating_add(Weight::from_parts(3_416_623, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32clz(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_389_000 picoseconds. - Weight::from_parts(2_551_000, 0) - // Standard Error: 5_708 - .saturating_add(Weight::from_parts(3_133_430, 0).saturating_mul(r.into())) + // Minimum execution time: 2_367_000 picoseconds. + Weight::from_parts(2_481_000, 0) + // Standard Error: 4_834 + .saturating_add(Weight::from_parts(3_141_274, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64ctz(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_428_000 picoseconds. - Weight::from_parts(2_511_000, 0) - // Standard Error: 7_262 - .saturating_add(Weight::from_parts(3_192_675, 0).saturating_mul(r.into())) + // Minimum execution time: 2_414_000 picoseconds. + Weight::from_parts(2_479_000, 0) + // Standard Error: 5_384 + .saturating_add(Weight::from_parts(3_162_450, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32ctz(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_333_000 picoseconds. - Weight::from_parts(2_426_000, 0) - // Standard Error: 4_554 - .saturating_add(Weight::from_parts(2_683_293, 0).saturating_mul(r.into())) + // Minimum execution time: 2_481_000 picoseconds. + Weight::from_parts(2_534_000, 0) + // Standard Error: 5_851 + .saturating_add(Weight::from_parts(2_742_009, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64popcnt(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_334_000 picoseconds. - Weight::from_parts(2_385_000, 0) - // Standard Error: 4_686 - .saturating_add(Weight::from_parts(631_609, 0).saturating_mul(r.into())) + // Minimum execution time: 2_444_000 picoseconds. + Weight::from_parts(2_522_000, 0) + // Standard Error: 5_551 + .saturating_add(Weight::from_parts(650_966, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32popcnt(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_356_000 picoseconds. - Weight::from_parts(1_221_890, 0) - // Standard Error: 3_960 - .saturating_add(Weight::from_parts(452_047, 0).saturating_mul(r.into())) + // Minimum execution time: 2_476_000 picoseconds. + Weight::from_parts(627_113, 0) + // Standard Error: 6_633 + .saturating_add(Weight::from_parts(527_272, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64eqz(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_318_000 picoseconds. - Weight::from_parts(2_390_000, 0) - // Standard Error: 11_114 - .saturating_add(Weight::from_parts(1_916_122, 0).saturating_mul(r.into())) + // Minimum execution time: 2_415_000 picoseconds. + Weight::from_parts(2_511_000, 0) + // Standard Error: 10_855 + .saturating_add(Weight::from_parts(1_987_179, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32eqz(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_436_000 picoseconds. - Weight::from_parts(2_504_000, 0) - // Standard Error: 7_104 - .saturating_add(Weight::from_parts(1_156_958, 0).saturating_mul(r.into())) + // Minimum execution time: 2_374_000 picoseconds. + Weight::from_parts(2_523_000, 0) + // Standard Error: 8_639 + .saturating_add(Weight::from_parts(1_265_345, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32extend8s(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_276_000 picoseconds. - Weight::from_parts(1_708_596, 0) - // Standard Error: 2_843 - .saturating_add(Weight::from_parts(377_083, 0).saturating_mul(r.into())) + // Minimum execution time: 2_385_000 picoseconds. + Weight::from_parts(1_218_539, 0) + // Standard Error: 5_119 + .saturating_add(Weight::from_parts(443_968, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32extend16s(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_386_000 picoseconds. - Weight::from_parts(1_424_415, 0) - // Standard Error: 3_599 - .saturating_add(Weight::from_parts(395_934, 0).saturating_mul(r.into())) + // Minimum execution time: 2_408_000 picoseconds. + Weight::from_parts(1_419_491, 0) + // Standard Error: 3_971 + .saturating_add(Weight::from_parts(429_566, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64extend8s(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_396_000 picoseconds. - Weight::from_parts(2_491_000, 0) - // Standard Error: 3_774 - .saturating_add(Weight::from_parts(516_281, 0).saturating_mul(r.into())) + // Minimum execution time: 2_442_000 picoseconds. + Weight::from_parts(2_534_000, 0) + // Standard Error: 5_488 + .saturating_add(Weight::from_parts(626_359, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64extend16s(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_308_000 picoseconds. - Weight::from_parts(548_192, 0) - // Standard Error: 4_583 - .saturating_add(Weight::from_parts(556_734, 0).saturating_mul(r.into())) + // Minimum execution time: 2_383_000 picoseconds. + Weight::from_parts(267_997, 0) + // Standard Error: 6_829 + .saturating_add(Weight::from_parts(639_304, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64extend32s(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_333_000 picoseconds. - Weight::from_parts(447_271, 0) - // Standard Error: 5_300 - .saturating_add(Weight::from_parts(535_915, 0).saturating_mul(r.into())) + // Minimum execution time: 2_336_000 picoseconds. + Weight::from_parts(2_524_000, 0) + // Standard Error: 4_090 + .saturating_add(Weight::from_parts(515_493, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64extendsi32(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_340_000 picoseconds. - Weight::from_parts(1_639_695, 0) - // Standard Error: 3_519 - .saturating_add(Weight::from_parts(368_523, 0).saturating_mul(r.into())) + // Minimum execution time: 2_419_000 picoseconds. + Weight::from_parts(1_479_176, 0) + // Standard Error: 4_590 + .saturating_add(Weight::from_parts(393_408, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64extendui32(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_305_000 picoseconds. - Weight::from_parts(2_843_474, 0) - // Standard Error: 1_950 - .saturating_add(Weight::from_parts(176_592, 0).saturating_mul(r.into())) + // Minimum execution time: 2_404_000 picoseconds. + Weight::from_parts(2_886_191, 0) + // Standard Error: 2_108 + .saturating_add(Weight::from_parts(180_952, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32wrapi64(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_351_000 picoseconds. - Weight::from_parts(2_894_613, 0) - // Standard Error: 2_024 - .saturating_add(Weight::from_parts(188_853, 0).saturating_mul(r.into())) + // Minimum execution time: 2_423_000 picoseconds. + Weight::from_parts(2_587_480, 0) + // Standard Error: 2_350 + .saturating_add(Weight::from_parts(202_312, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64eq(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_353_000 picoseconds. - Weight::from_parts(2_418_000, 0) - // Standard Error: 9_504 - .saturating_add(Weight::from_parts(1_936_605, 0).saturating_mul(r.into())) + // Minimum execution time: 2_457_000 picoseconds. + Weight::from_parts(2_558_000, 0) + // Standard Error: 9_756 + .saturating_add(Weight::from_parts(1_914_693, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32eq(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_291_000 picoseconds. - Weight::from_parts(2_364_000, 0) - // Standard Error: 8_346 - .saturating_add(Weight::from_parts(1_222_521, 0).saturating_mul(r.into())) + // Minimum execution time: 2_431_000 picoseconds. + Weight::from_parts(2_481_000, 0) + // Standard Error: 8_683 + .saturating_add(Weight::from_parts(1_235_014, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64ne(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_345_000 picoseconds. - Weight::from_parts(2_452_000, 0) - // Standard Error: 10_232 - .saturating_add(Weight::from_parts(1_883_867, 0).saturating_mul(r.into())) + // Minimum execution time: 2_418_000 picoseconds. + Weight::from_parts(2_533_000, 0) + // Standard Error: 9_762 + .saturating_add(Weight::from_parts(1_952_043, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32ne(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_323_000 picoseconds. - Weight::from_parts(2_387_000, 0) - // Standard Error: 7_581 - .saturating_add(Weight::from_parts(1_200_178, 0).saturating_mul(r.into())) + // Minimum execution time: 2_444_000 picoseconds. + Weight::from_parts(2_542_000, 0) + // Standard Error: 8_692 + .saturating_add(Weight::from_parts(1_240_320, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64lts(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_410_000 picoseconds. - Weight::from_parts(2_459_000, 0) - // Standard Error: 11_139 - .saturating_add(Weight::from_parts(1_877_766, 0).saturating_mul(r.into())) + // Minimum execution time: 2_415_000 picoseconds. + Weight::from_parts(2_535_000, 0) + // Standard Error: 10_660 + .saturating_add(Weight::from_parts(1_944_040, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32lts(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_273_000 picoseconds. - Weight::from_parts(2_387_000, 0) - // Standard Error: 8_083 - .saturating_add(Weight::from_parts(1_217_904, 0).saturating_mul(r.into())) + // Minimum execution time: 2_365_000 picoseconds. + Weight::from_parts(2_469_000, 0) + // Standard Error: 7_760 + .saturating_add(Weight::from_parts(1_232_925, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64ltu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_403_000 picoseconds. - Weight::from_parts(2_482_000, 0) - // Standard Error: 11_044 - .saturating_add(Weight::from_parts(1_956_302, 0).saturating_mul(r.into())) + // Minimum execution time: 2_445_000 picoseconds. + Weight::from_parts(2_496_000, 0) + // Standard Error: 10_669 + .saturating_add(Weight::from_parts(1_917_582, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32ltu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_353_000 picoseconds. - Weight::from_parts(2_420_000, 0) - // Standard Error: 7_870 - .saturating_add(Weight::from_parts(1_213_570, 0).saturating_mul(r.into())) + // Minimum execution time: 2_393_000 picoseconds. + Weight::from_parts(2_455_000, 0) + // Standard Error: 8_096 + .saturating_add(Weight::from_parts(1_210_306, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64gts(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_364_000 picoseconds. - Weight::from_parts(2_430_000, 0) - // Standard Error: 10_577 - .saturating_add(Weight::from_parts(1_968_043, 0).saturating_mul(r.into())) + // Minimum execution time: 2_351_000 picoseconds. + Weight::from_parts(2_463_000, 0) + // Standard Error: 10_885 + .saturating_add(Weight::from_parts(1_890_425, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32gts(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_328_000 picoseconds. - Weight::from_parts(2_442_000, 0) - // Standard Error: 7_838 - .saturating_add(Weight::from_parts(1_267_211, 0).saturating_mul(r.into())) + // Minimum execution time: 2_460_000 picoseconds. + Weight::from_parts(2_542_000, 0) + // Standard Error: 9_229 + .saturating_add(Weight::from_parts(1_236_149, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64gtu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_395_000 picoseconds. - Weight::from_parts(2_460_000, 0) - // Standard Error: 10_856 - .saturating_add(Weight::from_parts(1_910_357, 0).saturating_mul(r.into())) + // Minimum execution time: 2_438_000 picoseconds. + Weight::from_parts(2_519_000, 0) + // Standard Error: 10_023 + .saturating_add(Weight::from_parts(1_937_593, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32gtu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_343_000 picoseconds. - Weight::from_parts(2_409_000, 0) - // Standard Error: 5_786 - .saturating_add(Weight::from_parts(1_128_653, 0).saturating_mul(r.into())) + // Minimum execution time: 2_414_000 picoseconds. + Weight::from_parts(2_509_000, 0) + // Standard Error: 8_360 + .saturating_add(Weight::from_parts(1_234_039, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64les(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_318_000 picoseconds. - Weight::from_parts(2_433_000, 0) - // Standard Error: 10_344 - .saturating_add(Weight::from_parts(1_897_480, 0).saturating_mul(r.into())) + // Minimum execution time: 2_354_000 picoseconds. + Weight::from_parts(2_409_000, 0) + // Standard Error: 10_328 + .saturating_add(Weight::from_parts(1_926_867, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32les(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_355_000 picoseconds. - Weight::from_parts(2_460_000, 0) - // Standard Error: 6_963 - .saturating_add(Weight::from_parts(1_125_698, 0).saturating_mul(r.into())) + // Minimum execution time: 2_404_000 picoseconds. + Weight::from_parts(2_498_000, 0) + // Standard Error: 6_744 + .saturating_add(Weight::from_parts(1_201_302, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64leu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_356_000 picoseconds. - Weight::from_parts(2_447_000, 0) - // Standard Error: 8_285 - .saturating_add(Weight::from_parts(1_848_149, 0).saturating_mul(r.into())) + // Minimum execution time: 2_410_000 picoseconds. + Weight::from_parts(2_483_000, 0) + // Standard Error: 9_487 + .saturating_add(Weight::from_parts(1_900_378, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32leu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_327_000 picoseconds. - Weight::from_parts(2_394_000, 0) - // Standard Error: 7_282 - .saturating_add(Weight::from_parts(1_176_423, 0).saturating_mul(r.into())) + // Minimum execution time: 2_387_000 picoseconds. + Weight::from_parts(2_459_000, 0) + // Standard Error: 7_524 + .saturating_add(Weight::from_parts(1_246_740, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64ges(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_372_000 picoseconds. - Weight::from_parts(2_439_000, 0) - // Standard Error: 9_207 - .saturating_add(Weight::from_parts(1_837_009, 0).saturating_mul(r.into())) + // Minimum execution time: 2_452_000 picoseconds. + Weight::from_parts(2_532_000, 0) + // Standard Error: 9_466 + .saturating_add(Weight::from_parts(1_877_147, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32ges(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_368_000 picoseconds. - Weight::from_parts(2_427_000, 0) - // Standard Error: 8_320 - .saturating_add(Weight::from_parts(1_231_088, 0).saturating_mul(r.into())) + // Minimum execution time: 2_374_000 picoseconds. + Weight::from_parts(2_541_000, 0) + // Standard Error: 8_268 + .saturating_add(Weight::from_parts(1_218_632, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64geu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_373_000 picoseconds. - Weight::from_parts(2_461_000, 0) - // Standard Error: 9_499 - .saturating_add(Weight::from_parts(1_922_588, 0).saturating_mul(r.into())) + // Minimum execution time: 2_393_000 picoseconds. + Weight::from_parts(2_485_000, 0) + // Standard Error: 9_288 + .saturating_add(Weight::from_parts(1_892_308, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32geu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_387_000 picoseconds. - Weight::from_parts(2_455_000, 0) - // Standard Error: 7_681 - .saturating_add(Weight::from_parts(1_198_894, 0).saturating_mul(r.into())) + // Minimum execution time: 2_416_000 picoseconds. + Weight::from_parts(2_490_000, 0) + // Standard Error: 7_514 + .saturating_add(Weight::from_parts(1_221_546, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64add(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_308_000 picoseconds. - Weight::from_parts(2_389_000, 0) - // Standard Error: 7_797 - .saturating_add(Weight::from_parts(1_286_566, 0).saturating_mul(r.into())) + // Minimum execution time: 2_396_000 picoseconds. + Weight::from_parts(2_479_000, 0) + // Standard Error: 8_638 + .saturating_add(Weight::from_parts(1_370_587, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32add(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_329_000 picoseconds. - Weight::from_parts(2_389_000, 0) - // Standard Error: 4_968 - .saturating_add(Weight::from_parts(645_254, 0).saturating_mul(r.into())) + // Minimum execution time: 2_364_000 picoseconds. + Weight::from_parts(2_433_000, 0) + // Standard Error: 7_144 + .saturating_add(Weight::from_parts(740_923, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64sub(r: u32, ) -> Weight { @@ -1810,286 +1812,286 @@ impl pallet_gear::WeightInfo for SubstrateWeight { // Measured: `0` // Estimated: `0` // Minimum execution time: 2_409_000 picoseconds. - Weight::from_parts(2_489_000, 0) - // Standard Error: 7_055 - .saturating_add(Weight::from_parts(1_232_084, 0).saturating_mul(r.into())) + Weight::from_parts(2_490_000, 0) + // Standard Error: 7_493 + .saturating_add(Weight::from_parts(1_344_150, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32sub(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_371_000 picoseconds. - Weight::from_parts(2_420_000, 0) - // Standard Error: 4_348 - .saturating_add(Weight::from_parts(633_810, 0).saturating_mul(r.into())) + // Minimum execution time: 2_332_000 picoseconds. + Weight::from_parts(2_408_000, 0) + // Standard Error: 5_062 + .saturating_add(Weight::from_parts(682_810, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64mul(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_336_000 picoseconds. - Weight::from_parts(2_413_000, 0) - // Standard Error: 8_202 - .saturating_add(Weight::from_parts(1_777_425, 0).saturating_mul(r.into())) + // Minimum execution time: 2_357_000 picoseconds. + Weight::from_parts(2_429_000, 0) + // Standard Error: 8_825 + .saturating_add(Weight::from_parts(1_852_934, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32mul(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_314_000 picoseconds. - Weight::from_parts(2_369_000, 0) - // Standard Error: 6_935 - .saturating_add(Weight::from_parts(1_201_570, 0).saturating_mul(r.into())) + // Minimum execution time: 2_379_000 picoseconds. + Weight::from_parts(2_477_000, 0) + // Standard Error: 7_950 + .saturating_add(Weight::from_parts(1_310_475, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64divs(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_276_000 picoseconds. - Weight::from_parts(6_846_840, 0) - // Standard Error: 17_822 - .saturating_add(Weight::from_parts(2_268_370, 0).saturating_mul(r.into())) + // Minimum execution time: 2_486_000 picoseconds. + Weight::from_parts(7_409_149, 0) + // Standard Error: 23_280 + .saturating_add(Weight::from_parts(2_380_599, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32divs(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_394_000 picoseconds. - Weight::from_parts(4_704_336, 0) - // Standard Error: 10_960 - .saturating_add(Weight::from_parts(2_182_711, 0).saturating_mul(r.into())) + // Minimum execution time: 2_354_000 picoseconds. + Weight::from_parts(3_985_947, 0) + // Standard Error: 17_253 + .saturating_add(Weight::from_parts(2_308_046, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64divu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_375_000 picoseconds. - Weight::from_parts(1_968_824, 0) - // Standard Error: 15_899 - .saturating_add(Weight::from_parts(2_762_269, 0).saturating_mul(r.into())) + // Minimum execution time: 2_428_000 picoseconds. + Weight::from_parts(5_185_413, 0) + // Standard Error: 23_626 + .saturating_add(Weight::from_parts(2_773_914, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32divu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_335_000 picoseconds. - Weight::from_parts(1_450_000, 0) - // Standard Error: 13_496 - .saturating_add(Weight::from_parts(2_401_407, 0).saturating_mul(r.into())) + // Minimum execution time: 2_429_000 picoseconds. + Weight::from_parts(1_762_312, 0) + // Standard Error: 13_137 + .saturating_add(Weight::from_parts(2_479_857, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64rems(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_448_000 picoseconds. - Weight::from_parts(2_513_000, 0) - // Standard Error: 19_401 - .saturating_add(Weight::from_parts(9_309_211, 0).saturating_mul(r.into())) + // Minimum execution time: 2_409_000 picoseconds. + Weight::from_parts(6_183_774, 0) + // Standard Error: 38_390 + .saturating_add(Weight::from_parts(9_036_753, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32rems(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_273_000 picoseconds. - Weight::from_parts(1_738_370, 0) - // Standard Error: 42_672 - .saturating_add(Weight::from_parts(7_512_557, 0).saturating_mul(r.into())) + // Minimum execution time: 2_365_000 picoseconds. + Weight::from_parts(4_139_889, 0) + // Standard Error: 41_118 + .saturating_add(Weight::from_parts(7_440_928, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64remu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_371_000 picoseconds. - Weight::from_parts(2_215_088, 0) - // Standard Error: 15_445 - .saturating_add(Weight::from_parts(2_956_278, 0).saturating_mul(r.into())) + // Minimum execution time: 2_381_000 picoseconds. + Weight::from_parts(6_243_134, 0) + // Standard Error: 22_183 + .saturating_add(Weight::from_parts(2_805_045, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32remu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_409_000 picoseconds. - Weight::from_parts(217_500, 0) - // Standard Error: 7_904 - .saturating_add(Weight::from_parts(2_576_151, 0).saturating_mul(r.into())) + // Minimum execution time: 2_235_000 picoseconds. + Weight::from_parts(3_471_941, 0) + // Standard Error: 17_840 + .saturating_add(Weight::from_parts(2_399_950, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64and(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_456_000 picoseconds. - Weight::from_parts(2_503_000, 0) - // Standard Error: 7_920 - .saturating_add(Weight::from_parts(1_321_543, 0).saturating_mul(r.into())) + // Minimum execution time: 2_386_000 picoseconds. + Weight::from_parts(2_442_000, 0) + // Standard Error: 9_450 + .saturating_add(Weight::from_parts(1_363_334, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32and(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_346_000 picoseconds. - Weight::from_parts(2_479_000, 0) - // Standard Error: 4_711 - .saturating_add(Weight::from_parts(689_892, 0).saturating_mul(r.into())) + // Minimum execution time: 2_344_000 picoseconds. + Weight::from_parts(2_515_000, 0) + // Standard Error: 5_086 + .saturating_add(Weight::from_parts(682_806, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64or(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_339_000 picoseconds. - Weight::from_parts(2_427_000, 0) - // Standard Error: 8_029 - .saturating_add(Weight::from_parts(1_256_838, 0).saturating_mul(r.into())) + // Minimum execution time: 2_426_000 picoseconds. + Weight::from_parts(2_542_000, 0) + // Standard Error: 9_043 + .saturating_add(Weight::from_parts(1_383_826, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32or(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_334_000 picoseconds. - Weight::from_parts(2_480_000, 0) - // Standard Error: 3_812 - .saturating_add(Weight::from_parts(607_420, 0).saturating_mul(r.into())) + // Minimum execution time: 2_462_000 picoseconds. + Weight::from_parts(2_534_000, 0) + // Standard Error: 5_704 + .saturating_add(Weight::from_parts(687_779, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64xor(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_328_000 picoseconds. - Weight::from_parts(2_392_000, 0) - // Standard Error: 7_362 - .saturating_add(Weight::from_parts(1_248_739, 0).saturating_mul(r.into())) + // Minimum execution time: 2_386_000 picoseconds. + Weight::from_parts(2_437_000, 0) + // Standard Error: 7_683 + .saturating_add(Weight::from_parts(1_343_755, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32xor(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_419_000 picoseconds. - Weight::from_parts(2_465_000, 0) - // Standard Error: 4_304 - .saturating_add(Weight::from_parts(604_813, 0).saturating_mul(r.into())) + // Minimum execution time: 2_376_000 picoseconds. + Weight::from_parts(2_482_000, 0) + // Standard Error: 4_933 + .saturating_add(Weight::from_parts(708_732, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64shl(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_298_000 picoseconds. - Weight::from_parts(2_433_000, 0) - // Standard Error: 8_043 - .saturating_add(Weight::from_parts(1_073_194, 0).saturating_mul(r.into())) + // Minimum execution time: 2_449_000 picoseconds. + Weight::from_parts(2_532_000, 0) + // Standard Error: 6_389 + .saturating_add(Weight::from_parts(1_180_854, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32shl(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_427_000 picoseconds. - Weight::from_parts(2_511_000, 0) - // Standard Error: 4_969 - .saturating_add(Weight::from_parts(594_802, 0).saturating_mul(r.into())) + // Minimum execution time: 2_349_000 picoseconds. + Weight::from_parts(2_425_000, 0) + // Standard Error: 4_313 + .saturating_add(Weight::from_parts(633_941, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64shrs(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_312_000 picoseconds. - Weight::from_parts(2_399_000, 0) - // Standard Error: 7_093 - .saturating_add(Weight::from_parts(1_110_114, 0).saturating_mul(r.into())) + // Minimum execution time: 2_467_000 picoseconds. + Weight::from_parts(2_512_000, 0) + // Standard Error: 8_780 + .saturating_add(Weight::from_parts(1_192_503, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32shrs(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_331_000 picoseconds. - Weight::from_parts(2_433_000, 0) - // Standard Error: 4_140 - .saturating_add(Weight::from_parts(600_354, 0).saturating_mul(r.into())) + // Minimum execution time: 2_527_000 picoseconds. + Weight::from_parts(2_588_000, 0) + // Standard Error: 4_176 + .saturating_add(Weight::from_parts(593_049, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64shru(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_300_000 picoseconds. - Weight::from_parts(2_419_000, 0) - // Standard Error: 7_150 - .saturating_add(Weight::from_parts(1_154_649, 0).saturating_mul(r.into())) + // Minimum execution time: 2_415_000 picoseconds. + Weight::from_parts(2_530_000, 0) + // Standard Error: 7_794 + .saturating_add(Weight::from_parts(1_154_673, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32shru(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_356_000 picoseconds. - Weight::from_parts(2_423_000, 0) - // Standard Error: 5_067 - .saturating_add(Weight::from_parts(594_487, 0).saturating_mul(r.into())) + // Minimum execution time: 2_440_000 picoseconds. + Weight::from_parts(2_524_000, 0) + // Standard Error: 5_453 + .saturating_add(Weight::from_parts(633_003, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64rotl(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_339_000 picoseconds. - Weight::from_parts(2_406_000, 0) - // Standard Error: 5_674 - .saturating_add(Weight::from_parts(1_051_819, 0).saturating_mul(r.into())) + // Minimum execution time: 2_341_000 picoseconds. + Weight::from_parts(2_378_000, 0) + // Standard Error: 8_555 + .saturating_add(Weight::from_parts(1_196_751, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32rotl(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_383_000 picoseconds. - Weight::from_parts(114_723, 0) - // Standard Error: 5_881 - .saturating_add(Weight::from_parts(646_798, 0).saturating_mul(r.into())) + // Minimum execution time: 2_395_000 picoseconds. + Weight::from_parts(2_496_000, 0) + // Standard Error: 4_682 + .saturating_add(Weight::from_parts(627_173, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64rotr(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_292_000 picoseconds. - Weight::from_parts(2_422_000, 0) - // Standard Error: 6_697 - .saturating_add(Weight::from_parts(1_053_580, 0).saturating_mul(r.into())) + // Minimum execution time: 2_380_000 picoseconds. + Weight::from_parts(2_444_000, 0) + // Standard Error: 7_964 + .saturating_add(Weight::from_parts(1_141_337, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32rotr(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_325_000 picoseconds. - Weight::from_parts(206_699, 0) - // Standard Error: 5_851 - .saturating_add(Weight::from_parts(639_333, 0).saturating_mul(r.into())) + // Minimum execution time: 2_442_000 picoseconds. + Weight::from_parts(2_531_000, 0) + // Standard Error: 5_193 + .saturating_add(Weight::from_parts(628_586, 0).saturating_mul(r.into())) } fn tasks_remove_resume_session() -> Weight { // Proof Size summary in bytes: // Measured: `352` // Estimated: `4169` - // Minimum execution time: 6_081_000 picoseconds. - Weight::from_parts(6_314_000, 4169) + // Minimum execution time: 5_990_000 picoseconds. + Weight::from_parts(6_384_000, 4169) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) } @@ -2097,8 +2099,8 @@ impl pallet_gear::WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `1107` // Estimated: `24053` - // Minimum execution time: 61_245_000 picoseconds. - Weight::from_parts(64_310_000, 24053) + // Minimum execution time: 64_318_000 picoseconds. + Weight::from_parts(67_713_000, 24053) .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().writes(6_u64)) } @@ -2106,8 +2108,8 @@ impl pallet_gear::WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `888` // Estimated: `22158` - // Minimum execution time: 47_184_000 picoseconds. - Weight::from_parts(48_335_000, 22158) + // Minimum execution time: 50_396_000 picoseconds. + Weight::from_parts(57_319_000, 22158) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().writes(5_u64)) } @@ -2115,8 +2117,8 @@ impl pallet_gear::WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `1010` // Estimated: `34619` - // Minimum execution time: 75_767_000 picoseconds. - Weight::from_parts(77_229_000, 34619) + // Minimum execution time: 81_192_000 picoseconds. + Weight::from_parts(110_464_000, 34619) .saturating_add(T::DbWeight::get().reads(11_u64)) .saturating_add(T::DbWeight::get().writes(10_u64)) } @@ -2124,8 +2126,8 @@ impl pallet_gear::WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `695` // Estimated: `20509` - // Minimum execution time: 31_513_000 picoseconds. - Weight::from_parts(33_232_000, 20509) + // Minimum execution time: 33_549_000 picoseconds. + Weight::from_parts(35_457_000, 20509) .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().writes(6_u64)) } @@ -2133,8 +2135,8 @@ impl pallet_gear::WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `976` // Estimated: `26636` - // Minimum execution time: 48_739_000 picoseconds. - Weight::from_parts(49_963_000, 26636) + // Minimum execution time: 53_062_000 picoseconds. + Weight::from_parts(55_913_000, 26636) .saturating_add(T::DbWeight::get().reads(8_u64)) .saturating_add(T::DbWeight::get().writes(6_u64)) } @@ -2142,16 +2144,16 @@ impl pallet_gear::WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `80` // Estimated: `3545` - // Minimum execution time: 3_513_000 picoseconds. - Weight::from_parts(3_670_000, 3545) + // Minimum execution time: 3_544_000 picoseconds. + Weight::from_parts(3_797_000, 3545) .saturating_add(T::DbWeight::get().reads(1_u64)) } fn tasks_remove_from_waitlist() -> Weight { // Proof Size summary in bytes: // Measured: `1626` // Estimated: `58232` - // Minimum execution time: 109_582_000 picoseconds. - Weight::from_parts(112_343_000, 58232) + // Minimum execution time: 119_636_000 picoseconds. + Weight::from_parts(122_812_000, 58232) .saturating_add(T::DbWeight::get().reads(16_u64)) .saturating_add(T::DbWeight::get().writes(13_u64)) } @@ -2159,8 +2161,8 @@ impl pallet_gear::WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `1332` // Estimated: `46962` - // Minimum execution time: 90_789_000 picoseconds. - Weight::from_parts(93_329_000, 46962) + // Minimum execution time: 94_503_000 picoseconds. + Weight::from_parts(98_976_000, 46962) .saturating_add(T::DbWeight::get().reads(14_u64)) .saturating_add(T::DbWeight::get().writes(13_u64)) } @@ -2169,10 +2171,10 @@ impl pallet_gear::WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `2303 + c * (16400 ±0)` // Estimated: `19878 + c * (84480 ±0)` - // Minimum execution time: 31_262_000 picoseconds. - Weight::from_parts(31_610_000, 19878) - // Standard Error: 69_131 - .saturating_add(Weight::from_parts(39_928_419, 0).saturating_mul(c.into())) + // Minimum execution time: 31_538_000 picoseconds. + Weight::from_parts(32_681_000, 19878) + // Standard Error: 71_008 + .saturating_add(Weight::from_parts(39_112_947, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(4_u64)) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(c.into()))) .saturating_add(T::DbWeight::get().writes(2_u64)) @@ -2184,10 +2186,10 @@ impl pallet_gear::WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `3129 + c * (42 ±0)` // Estimated: `60575 + c * (2947 ±0)` - // Minimum execution time: 91_223_000 picoseconds. - Weight::from_parts(98_002_861, 60575) - // Standard Error: 2_086 - .saturating_add(Weight::from_parts(1_092_801, 0).saturating_mul(c.into())) + // Minimum execution time: 91_887_000 picoseconds. + Weight::from_parts(87_209_551, 60575) + // Standard Error: 2_248 + .saturating_add(Weight::from_parts(1_083_157, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(13_u64)) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(c.into()))) .saturating_add(T::DbWeight::get().writes(9_u64)) @@ -2198,6 +2200,136 @@ impl pallet_gear::WeightInfo for SubstrateWeight { // For backwards compatibility and tests impl WeightInfo for () { + /// The range of component `r` is `[0, 1]`. + fn gr_reply(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 94_967_000 picoseconds. + Weight::from_parts(100_769_202, 0) + // Standard Error: 78_239 + .saturating_add(Weight::from_parts(21_623_874, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_reply_wgas(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 96_625_000 picoseconds. + Weight::from_parts(103_100_672, 0) + // Standard Error: 79_915 + .saturating_add(Weight::from_parts(18_339_856, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_reply_commit(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 95_620_000 picoseconds. + Weight::from_parts(102_660_230, 0) + // Standard Error: 81_604 + .saturating_add(Weight::from_parts(18_180_584, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_reply_commit_wgas(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 95_037_000 picoseconds. + Weight::from_parts(101_912_864, 0) + // Standard Error: 84_108 + .saturating_add(Weight::from_parts(20_742_928, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_reply_input(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 716_479_000 picoseconds. + Weight::from_parts(752_477_538, 0) + // Standard Error: 630_784 + .saturating_add(Weight::from_parts(22_929_588, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_reply_input_wgas(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 726_949_000 picoseconds. + Weight::from_parts(774_347_474, 0) + // Standard Error: 902_271 + .saturating_add(Weight::from_parts(17_273_758, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_reservation_reply(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 103_653_000 picoseconds. + Weight::from_parts(110_681_190, 0) + // Standard Error: 90_520 + .saturating_add(Weight::from_parts(12_801_500, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_reservation_reply_commit(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 105_389_000 picoseconds. + Weight::from_parts(113_272_838, 0) + // Standard Error: 89_344 + .saturating_add(Weight::from_parts(5_340_718, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_exit(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 96_868_000 picoseconds. + Weight::from_parts(104_048_366, 0) + // Standard Error: 2_216_528 + .saturating_add(Weight::from_parts(541_182_376, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_leave(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 94_494_000 picoseconds. + Weight::from_parts(103_419_240, 0) + // Standard Error: 2_066_261 + .saturating_add(Weight::from_parts(536_063_286, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_wait(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 96_167_000 picoseconds. + Weight::from_parts(103_413_378, 0) + // Standard Error: 2_011_359 + .saturating_add(Weight::from_parts(519_142_196, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_wait_for(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 93_437_000 picoseconds. + Weight::from_parts(100_205_340, 0) + // Standard Error: 2_405_150 + .saturating_add(Weight::from_parts(547_275_968, 0).saturating_mul(r.into())) + } + /// The range of component `r` is `[0, 1]`. + fn gr_wait_up_to(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 95_803_000 picoseconds. + Weight::from_parts(102_665_234, 0) + // Standard Error: 2_225_197 + .saturating_add(Weight::from_parts(553_575_546, 0).saturating_mul(r.into())) + } fn allocation_cost() -> Weight { // To be changed with the proper value. RocksDbWeight::get().writes(1) @@ -2217,10 +2349,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_023_000 picoseconds. - Weight::from_parts(1_051_000, 0) - // Standard Error: 912 - .saturating_add(Weight::from_parts(213_761, 0).saturating_mul(c.into())) + // Minimum execution time: 976_000 picoseconds. + Weight::from_parts(1_072_000, 0) + // Standard Error: 699 + .saturating_add(Weight::from_parts(245_833, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().writes(1_u64)) } /// The range of component `c` is `[0, 512]`. @@ -2228,10 +2360,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `146 + c * (1024 ±0)` // Estimated: `3610 + c * (1024 ±0)` - // Minimum execution time: 3_252_000 picoseconds. - Weight::from_parts(3_416_000, 3610) - // Standard Error: 1_261 - .saturating_add(Weight::from_parts(689_572, 0).saturating_mul(c.into())) + // Minimum execution time: 3_396_000 picoseconds. + Weight::from_parts(3_490_000, 3610) + // Standard Error: 1_049 + .saturating_add(Weight::from_parts(676_643, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(Weight::from_parts(0, 1024).saturating_mul(c.into())) } @@ -2240,17 +2372,17 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 59_805_000 picoseconds. - Weight::from_parts(86_729_126, 0) - // Standard Error: 7_023 - .saturating_add(Weight::from_parts(2_475_519, 0).saturating_mul(c.into())) + // Minimum execution time: 62_736_000 picoseconds. + Weight::from_parts(76_636_221, 0) + // Standard Error: 9_825 + .saturating_add(Weight::from_parts(2_570_922, 0).saturating_mul(c.into())) } fn claim_value() -> Weight { // Proof Size summary in bytes: // Measured: `1372` // Estimated: `51905` - // Minimum execution time: 107_694_000 picoseconds. - Weight::from_parts(110_328_000, 51905) + // Minimum execution time: 111_461_000 picoseconds. + Weight::from_parts(114_029_000, 51905) .saturating_add(RocksDbWeight::get().reads(15_u64)) .saturating_add(RocksDbWeight::get().writes(12_u64)) } @@ -2258,8 +2390,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `992` // Estimated: `21579` - // Minimum execution time: 55_980_000 picoseconds. - Weight::from_parts(56_766_000, 21579) + // Minimum execution time: 57_697_000 picoseconds. + Weight::from_parts(58_842_000, 21579) .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().writes(6_u64)) } @@ -2267,8 +2399,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `638` // Estimated: `17486` - // Minimum execution time: 29_973_000 picoseconds. - Weight::from_parts(31_008_000, 17486) + // Minimum execution time: 30_530_000 picoseconds. + Weight::from_parts(32_003_000, 17486) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().writes(4_u64)) } @@ -2277,10 +2409,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `355` // Estimated: `7640` - // Minimum execution time: 8_054_000 picoseconds. - Weight::from_parts(8_342_000, 7640) - // Standard Error: 17_771 - .saturating_add(Weight::from_parts(13_335_661, 0).saturating_mul(c.into())) + // Minimum execution time: 8_274_000 picoseconds. + Weight::from_parts(8_261_331, 7640) + // Standard Error: 41_108 + .saturating_add(Weight::from_parts(13_969_743, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) } @@ -2289,10 +2421,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `1593 + c * (16389 ±0)` // Estimated: `43266 + c * (131112 ±0)` - // Minimum execution time: 72_178_000 picoseconds. - Weight::from_parts(73_341_000, 43266) - // Standard Error: 167_723 - .saturating_add(Weight::from_parts(54_442_045, 0).saturating_mul(c.into())) + // Minimum execution time: 74_444_000 picoseconds. + Weight::from_parts(75_016_000, 43266) + // Standard Error: 165_690 + .saturating_add(Weight::from_parts(55_174_777, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(11_u64)) .saturating_add(RocksDbWeight::get().writes(9_u64)) .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(c.into()))) @@ -2303,10 +2435,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `113` // Estimated: `5402` - // Minimum execution time: 78_662_000 picoseconds. - Weight::from_parts(42_066_175, 5402) - // Standard Error: 52_075 - .saturating_add(Weight::from_parts(60_249_549, 0).saturating_mul(c.into())) + // Minimum execution time: 79_739_000 picoseconds. + Weight::from_parts(1_118_426, 5402) + // Standard Error: 68_897 + .saturating_add(Weight::from_parts(60_115_395, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(4_u64)) } @@ -2315,10 +2447,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `1111` // Estimated: `50600` - // Minimum execution time: 94_321_000 picoseconds. - Weight::from_parts(129_113_540, 50600) - // Standard Error: 1 - .saturating_add(Weight::from_parts(2_625, 0).saturating_mul(s.into())) + // Minimum execution time: 96_509_000 picoseconds. + Weight::from_parts(129_317_147, 50600) + // Standard Error: 0 + .saturating_add(Weight::from_parts(2_581, 0).saturating_mul(s.into())) .saturating_add(RocksDbWeight::get().reads(15_u64)) .saturating_add(RocksDbWeight::get().writes(12_u64)) } @@ -2328,12 +2460,12 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `521` // Estimated: `45152` - // Minimum execution time: 11_148_491_000 picoseconds. - Weight::from_parts(21_065_971, 45152) - // Standard Error: 173_883 - .saturating_add(Weight::from_parts(60_839_567, 0).saturating_mul(c.into())) - // Standard Error: 10 - .saturating_add(Weight::from_parts(2_652, 0).saturating_mul(s.into())) + // Minimum execution time: 10_940_898_000 picoseconds. + Weight::from_parts(67_432_582, 45152) + // Standard Error: 159_611 + .saturating_add(Weight::from_parts(61_428_399, 0).saturating_mul(c.into())) + // Standard Error: 9 + .saturating_add(Weight::from_parts(2_577, 0).saturating_mul(s.into())) .saturating_add(RocksDbWeight::get().reads(15_u64)) .saturating_add(RocksDbWeight::get().writes(16_u64)) } @@ -2342,10 +2474,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `531` // Estimated: `31266` - // Minimum execution time: 73_302_000 picoseconds. - Weight::from_parts(47_279_667, 31266) + // Minimum execution time: 77_245_000 picoseconds. + Weight::from_parts(59_204_735, 31266) // Standard Error: 1 - .saturating_add(Weight::from_parts(1_055, 0).saturating_mul(p.into())) + .saturating_add(Weight::from_parts(1_042, 0).saturating_mul(p.into())) .saturating_add(RocksDbWeight::get().reads(11_u64)) .saturating_add(RocksDbWeight::get().writes(10_u64)) } @@ -2354,33 +2486,33 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `1371` // Estimated: `54435` - // Minimum execution time: 124_173_000 picoseconds. - Weight::from_parts(96_458_887, 54435) + // Minimum execution time: 128_271_000 picoseconds. + Weight::from_parts(93_877_619, 54435) // Standard Error: 2 - .saturating_add(Weight::from_parts(1_078, 0).saturating_mul(p.into())) + .saturating_add(Weight::from_parts(1_085, 0).saturating_mul(p.into())) .saturating_add(RocksDbWeight::get().reads(16_u64)) .saturating_add(RocksDbWeight::get().writes(13_u64)) } /// The range of component `q` is `[1, 512]`. fn initial_allocation(_q: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `1893` - // Estimated: `114612` - // Minimum execution time: 365_983_000 picoseconds. - Weight::from_parts(387_416_952, 114612) - .saturating_add(RocksDbWeight::get().reads(33_u64)) + // Measured: `1897` + // Estimated: `121468` + // Minimum execution time: 379_776_000 picoseconds. + Weight::from_parts(397_994_052, 121468) + .saturating_add(RocksDbWeight::get().reads(35_u64)) .saturating_add(RocksDbWeight::get().writes(26_u64)) } /// The range of component `q` is `[0, 512]`. fn alloc_in_handle(q: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `1893` - // Estimated: `114612` - // Minimum execution time: 380_430_000 picoseconds. - Weight::from_parts(403_376_118, 114612) - // Standard Error: 2_451 - .saturating_add(Weight::from_parts(1_137, 0).saturating_mul(q.into())) - .saturating_add(RocksDbWeight::get().reads(33_u64)) + // Measured: `1897` + // Estimated: `121468` + // Minimum execution time: 393_678_000 picoseconds. + Weight::from_parts(411_350_620, 121468) + // Standard Error: 1_741 + .saturating_add(Weight::from_parts(5_796, 0).saturating_mul(q.into())) + .saturating_add(RocksDbWeight::get().reads(35_u64)) .saturating_add(RocksDbWeight::get().writes(26_u64)) } /// The range of component `c` is `[0, 512]`. @@ -2388,10 +2520,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `211 + c * (1075 ±0)` // Estimated: `3899 + c * (2150 ±0)` - // Minimum execution time: 58_080_000 picoseconds. - Weight::from_parts(58_601_000, 3899) - // Standard Error: 36_083 - .saturating_add(Weight::from_parts(58_395_643, 0).saturating_mul(c.into())) + // Minimum execution time: 58_693_000 picoseconds. + Weight::from_parts(59_295_000, 3899) + // Standard Error: 33_015 + .saturating_add(Weight::from_parts(61_659_744, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) .saturating_add(Weight::from_parts(0, 2150).saturating_mul(c.into())) @@ -2401,638 +2533,510 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 91_412_000 picoseconds. - Weight::from_parts(94_168_000, 0) - // Standard Error: 3_806_298 - .saturating_add(Weight::from_parts(673_774_453, 0).saturating_mul(r.into())) + // Minimum execution time: 94_082_000 picoseconds. + Weight::from_parts(97_548_000, 0) + // Standard Error: 3_920_023 + .saturating_add(Weight::from_parts(729_307_729, 0).saturating_mul(r.into())) } /// The range of component `p` is `[1, 512]`. fn alloc_per_page(p: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 452_549_000 picoseconds. - Weight::from_parts(398_963_700, 0) - // Standard Error: 7_042 - .saturating_add(Weight::from_parts(29_406_609, 0).saturating_mul(p.into())) + // Minimum execution time: 491_508_000 picoseconds. + Weight::from_parts(463_051_109, 0) + // Standard Error: 421_338 + .saturating_add(Weight::from_parts(31_169_166, 0).saturating_mul(p.into())) } /// The range of component `r` is `[0, 20]`. fn free(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 207_052_000 picoseconds. - Weight::from_parts(209_606_478, 0) - // Standard Error: 255_281 - .saturating_add(Weight::from_parts(62_959_531, 0).saturating_mul(r.into())) + // Minimum execution time: 220_882_000 picoseconds. + Weight::from_parts(231_751_371, 0) + // Standard Error: 241_524 + .saturating_add(Weight::from_parts(62_988_026, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 256]`. fn gr_reserve_gas(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 97_729_000 picoseconds. - Weight::from_parts(105_964_750, 0) - // Standard Error: 4_847 - .saturating_add(Weight::from_parts(2_433_966, 0).saturating_mul(r.into())) + // Minimum execution time: 100_013_000 picoseconds. + Weight::from_parts(108_487_423, 0) + // Standard Error: 4_858 + .saturating_add(Weight::from_parts(2_524_407, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 256]`. fn gr_unreserve_gas(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 175_010_000 picoseconds. - Weight::from_parts(229_153_209, 0) - // Standard Error: 17_116 - .saturating_add(Weight::from_parts(1_991_260, 0).saturating_mul(r.into())) + // Minimum execution time: 182_206_000 picoseconds. + Weight::from_parts(218_782_104, 0) + // Standard Error: 14_768 + .saturating_add(Weight::from_parts(2_153_377, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_system_reserve_gas(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 94_696_000 picoseconds. - Weight::from_parts(119_674_535, 0) - // Standard Error: 387_178 - .saturating_add(Weight::from_parts(98_102_856, 0).saturating_mul(r.into())) + // Minimum execution time: 97_458_000 picoseconds. + Weight::from_parts(121_028_602, 0) + // Standard Error: 385_510 + .saturating_add(Weight::from_parts(95_782_527, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_message_id(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 95_794_000 picoseconds. - Weight::from_parts(89_931_979, 0) - // Standard Error: 371_349 - .saturating_add(Weight::from_parts(86_524_059, 0).saturating_mul(r.into())) + // Minimum execution time: 101_412_000 picoseconds. + Weight::from_parts(86_061_953, 0) + // Standard Error: 356_205 + .saturating_add(Weight::from_parts(87_923_229, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_program_id(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 97_924_000 picoseconds. - Weight::from_parts(84_041_201, 0) - // Standard Error: 327_841 - .saturating_add(Weight::from_parts(95_483_315, 0).saturating_mul(r.into())) + // Minimum execution time: 101_962_000 picoseconds. + Weight::from_parts(96_667_757, 0) + // Standard Error: 333_738 + .saturating_add(Weight::from_parts(84_955_970, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_source(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 97_122_000 picoseconds. - Weight::from_parts(86_789_268, 0) - // Standard Error: 353_259 - .saturating_add(Weight::from_parts(85_698_317, 0).saturating_mul(r.into())) + // Minimum execution time: 98_464_000 picoseconds. + Weight::from_parts(90_164_484, 0) + // Standard Error: 321_979 + .saturating_add(Weight::from_parts(85_647_809, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_value(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 94_821_000 picoseconds. - Weight::from_parts(92_694_130, 0) - // Standard Error: 340_146 - .saturating_add(Weight::from_parts(84_623_945, 0).saturating_mul(r.into())) + // Minimum execution time: 97_334_000 picoseconds. + Weight::from_parts(91_107_930, 0) + // Standard Error: 336_291 + .saturating_add(Weight::from_parts(85_501_563, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_value_available(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 93_840_000 picoseconds. - Weight::from_parts(87_888_572, 0) - // Standard Error: 369_465 - .saturating_add(Weight::from_parts(85_638_902, 0).saturating_mul(r.into())) + // Minimum execution time: 96_398_000 picoseconds. + Weight::from_parts(97_803_650, 0) + // Standard Error: 330_728 + .saturating_add(Weight::from_parts(84_746_249, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_gas_available(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 98_597_000 picoseconds. - Weight::from_parts(86_642_386, 0) - // Standard Error: 362_257 - .saturating_add(Weight::from_parts(85_598_887, 0).saturating_mul(r.into())) + // Minimum execution time: 99_554_000 picoseconds. + Weight::from_parts(77_927_782, 0) + // Standard Error: 386_800 + .saturating_add(Weight::from_parts(90_358_021, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_size(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 94_546_000 picoseconds. - Weight::from_parts(91_466_289, 0) - // Standard Error: 344_423 - .saturating_add(Weight::from_parts(84_318_848, 0).saturating_mul(r.into())) + // Minimum execution time: 102_554_000 picoseconds. + Weight::from_parts(96_055_722, 0) + // Standard Error: 331_628 + .saturating_add(Weight::from_parts(84_542_244, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_read(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 578_036_000 picoseconds. - Weight::from_parts(696_140_951, 0) - // Standard Error: 559_498 - .saturating_add(Weight::from_parts(149_397_501, 0).saturating_mul(r.into())) + // Minimum execution time: 725_792_000 picoseconds. + Weight::from_parts(801_544_878, 0) + // Standard Error: 398_821 + .saturating_add(Weight::from_parts(140_715_634, 0).saturating_mul(r.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_read_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 723_788_000 picoseconds. - Weight::from_parts(740_225_000, 0) - // Standard Error: 52_895 - .saturating_add(Weight::from_parts(13_188_120, 0).saturating_mul(n.into())) + // Minimum execution time: 869_816_000 picoseconds. + Weight::from_parts(886_588_000, 0) + // Standard Error: 54_300 + .saturating_add(Weight::from_parts(13_214_277, 0).saturating_mul(n.into())) } /// The range of component `r` is `[0, 20]`. fn gr_block_height(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 99_012_000 picoseconds. - Weight::from_parts(88_269_135, 0) - // Standard Error: 296_136 - .saturating_add(Weight::from_parts(92_296_104, 0).saturating_mul(r.into())) + // Minimum execution time: 98_800_000 picoseconds. + Weight::from_parts(92_344_333, 0) + // Standard Error: 339_355 + .saturating_add(Weight::from_parts(86_790_706, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_block_timestamp(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 93_803_000 picoseconds. - Weight::from_parts(87_097_769, 0) - // Standard Error: 367_325 - .saturating_add(Weight::from_parts(84_987_043, 0).saturating_mul(r.into())) + // Minimum execution time: 97_651_000 picoseconds. + Weight::from_parts(92_529_847, 0) + // Standard Error: 295_105 + .saturating_add(Weight::from_parts(89_002_384, 0).saturating_mul(r.into())) } /// The range of component `n` is `[0, 20]`. fn gr_random(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 96_663_000 picoseconds. - Weight::from_parts(105_357_427, 0) - // Standard Error: 366_135 - .saturating_add(Weight::from_parts(172_109_201, 0).saturating_mul(n.into())) + // Minimum execution time: 99_357_000 picoseconds. + Weight::from_parts(105_767_963, 0) + // Standard Error: 380_641 + .saturating_add(Weight::from_parts(174_604_231, 0).saturating_mul(n.into())) } /// The range of component `r` is `[0, 20]`. fn gr_reply_deposit(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 99_210_000 picoseconds. - Weight::from_parts(102_217_000, 0) - // Standard Error: 4_527_119 - .saturating_add(Weight::from_parts(845_784_967, 0).saturating_mul(r.into())) + // Minimum execution time: 103_092_000 picoseconds. + Weight::from_parts(105_802_000, 0) + // Standard Error: 3_553_393 + .saturating_add(Weight::from_parts(783_848_741, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_send(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 96_579_000 picoseconds. - Weight::from_parts(162_452_429, 0) - // Standard Error: 416_836 - .saturating_add(Weight::from_parts(257_900_517, 0).saturating_mul(r.into())) + // Minimum execution time: 97_050_000 picoseconds. + Weight::from_parts(174_923_994, 0) + // Standard Error: 430_038 + .saturating_add(Weight::from_parts(266_665_269, 0).saturating_mul(r.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_send_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 353_526_000 picoseconds. - Weight::from_parts(358_025_000, 0) - // Standard Error: 61_984 - .saturating_add(Weight::from_parts(21_521_461, 0).saturating_mul(n.into())) + // Minimum execution time: 357_531_000 picoseconds. + Weight::from_parts(365_896_000, 0) + // Standard Error: 59_017 + .saturating_add(Weight::from_parts(21_340_532, 0).saturating_mul(n.into())) } /// The range of component `r` is `[0, 20]`. fn gr_send_wgas(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 94_822_000 picoseconds. - Weight::from_parts(168_431_611, 0) - // Standard Error: 378_696 - .saturating_add(Weight::from_parts(263_135_958, 0).saturating_mul(r.into())) + // Minimum execution time: 98_643_000 picoseconds. + Weight::from_parts(185_395_839, 0) + // Standard Error: 402_403 + .saturating_add(Weight::from_parts(266_083_111, 0).saturating_mul(r.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_send_wgas_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 351_828_000 picoseconds. - Weight::from_parts(355_382_000, 0) - // Standard Error: 60_589 - .saturating_add(Weight::from_parts(21_325_400, 0).saturating_mul(n.into())) + // Minimum execution time: 361_853_000 picoseconds. + Weight::from_parts(371_175_000, 0) + // Standard Error: 62_531 + .saturating_add(Weight::from_parts(21_372_225, 0).saturating_mul(n.into())) } /// The range of component `r` is `[0, 20]`. fn gr_send_input(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 569_384_000 picoseconds. - Weight::from_parts(638_474_730, 0) - // Standard Error: 425_903 - .saturating_add(Weight::from_parts(275_691_711, 0).saturating_mul(r.into())) + // Minimum execution time: 731_246_000 picoseconds. + Weight::from_parts(827_016_024, 0) + // Standard Error: 456_568 + .saturating_add(Weight::from_parts(283_568_931, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_send_input_wgas(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 573_053_000 picoseconds. - Weight::from_parts(640_078_802, 0) - // Standard Error: 475_389 - .saturating_add(Weight::from_parts(284_337_155, 0).saturating_mul(r.into())) + // Minimum execution time: 725_315_000 picoseconds. + Weight::from_parts(814_525_892, 0) + // Standard Error: 535_531 + .saturating_add(Weight::from_parts(291_725_582, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_send_init(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 98_223_000 picoseconds. - Weight::from_parts(85_732_985, 0) - // Standard Error: 336_308 - .saturating_add(Weight::from_parts(92_936_006, 0).saturating_mul(r.into())) + // Minimum execution time: 100_930_000 picoseconds. + Weight::from_parts(86_911_409, 0) + // Standard Error: 308_962 + .saturating_add(Weight::from_parts(98_197_967, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_send_push(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_822_621_000 picoseconds. - Weight::from_parts(1_951_955_018, 0) - // Standard Error: 339_415 - .saturating_add(Weight::from_parts(157_557_756, 0).saturating_mul(r.into())) + // Minimum execution time: 1_871_002_000 picoseconds. + Weight::from_parts(2_023_643_652, 0) + // Standard Error: 354_203 + .saturating_add(Weight::from_parts(163_033_723, 0).saturating_mul(r.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_send_push_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 314_296_000 picoseconds. - Weight::from_parts(317_522_000, 0) - // Standard Error: 61_360 - .saturating_add(Weight::from_parts(29_499_741, 0).saturating_mul(n.into())) + // Minimum execution time: 321_280_000 picoseconds. + Weight::from_parts(326_774_000, 0) + // Standard Error: 53_820 + .saturating_add(Weight::from_parts(31_205_219, 0).saturating_mul(n.into())) } /// The range of component `r` is `[0, 20]`. fn gr_send_commit(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_835_106_000 picoseconds. - Weight::from_parts(1_948_516_646, 0) - // Standard Error: 382_008 - .saturating_add(Weight::from_parts(214_812_508, 0).saturating_mul(r.into())) + // Minimum execution time: 1_866_780_000 picoseconds. + Weight::from_parts(2_024_271_501, 0) + // Standard Error: 405_972 + .saturating_add(Weight::from_parts(225_776_414, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_send_commit_wgas(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_827_496_000 picoseconds. - Weight::from_parts(1_949_190_773, 0) - // Standard Error: 340_175 - .saturating_add(Weight::from_parts(218_001_536, 0).saturating_mul(r.into())) + // Minimum execution time: 1_875_608_000 picoseconds. + Weight::from_parts(2_019_090_196, 0) + // Standard Error: 346_810 + .saturating_add(Weight::from_parts(235_898_569, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_reservation_send(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 264_306_000 picoseconds. - Weight::from_parts(363_536_651, 0) - // Standard Error: 467_914 - .saturating_add(Weight::from_parts(265_564_072, 0).saturating_mul(r.into())) + // Minimum execution time: 263_903_000 picoseconds. + Weight::from_parts(339_925_241, 0) + // Standard Error: 414_003 + .saturating_add(Weight::from_parts(280_423_422, 0).saturating_mul(r.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_reservation_send_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 523_150_000 picoseconds. - Weight::from_parts(535_842_000, 0) - // Standard Error: 65_412 - .saturating_add(Weight::from_parts(21_698_063, 0).saturating_mul(n.into())) + // Minimum execution time: 535_212_000 picoseconds. + Weight::from_parts(545_222_000, 0) + // Standard Error: 58_250 + .saturating_add(Weight::from_parts(21_556_762, 0).saturating_mul(n.into())) } /// The range of component `r` is `[0, 20]`. fn gr_reservation_send_commit(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_974_743_000 picoseconds. - Weight::from_parts(2_096_494_995, 0) - // Standard Error: 474_778 - .saturating_add(Weight::from_parts(232_524_299, 0).saturating_mul(r.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_reply(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 94_139_000 picoseconds. - Weight::from_parts(101_775_569, 0) - // Standard Error: 452_439 - .saturating_add(Weight::from_parts(16_839_430, 0).saturating_mul(r.into())) + // Minimum execution time: 2_022_436_000 picoseconds. + Weight::from_parts(2_212_258_384, 0) + // Standard Error: 460_291 + .saturating_add(Weight::from_parts(249_403_133, 0).saturating_mul(r.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_reply_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 112_050_000 picoseconds. - Weight::from_parts(102_205_366, 0) - // Standard Error: 1_008 - .saturating_add(Weight::from_parts(431_304, 0).saturating_mul(n.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_reply_wgas(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 93_528_000 picoseconds. - Weight::from_parts(99_748_422, 0) - // Standard Error: 396_992 - .saturating_add(Weight::from_parts(20_536_877, 0).saturating_mul(r.into())) + // Minimum execution time: 117_080_000 picoseconds. + Weight::from_parts(104_765_276, 0) + // Standard Error: 994 + .saturating_add(Weight::from_parts(436_761, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_reply_wgas_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 117_832_000 picoseconds. - Weight::from_parts(104_552_847, 0) - // Standard Error: 1_402 - .saturating_add(Weight::from_parts(432_018, 0).saturating_mul(n.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_reply_commit(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 93_325_000 picoseconds. - Weight::from_parts(101_074_097, 0) - // Standard Error: 454_790 - .saturating_add(Weight::from_parts(20_838_102, 0).saturating_mul(r.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_reply_commit_wgas(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 93_800_000 picoseconds. - Weight::from_parts(102_249_326, 0) - // Standard Error: 463_488 - .saturating_add(Weight::from_parts(15_991_473, 0).saturating_mul(r.into())) + // Minimum execution time: 115_283_000 picoseconds. + Weight::from_parts(109_185_112, 0) + // Standard Error: 1_244 + .saturating_add(Weight::from_parts(432_177, 0).saturating_mul(n.into())) } /// The range of component `r` is `[0, 20]`. fn gr_reply_push(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 93_153_000 picoseconds. - Weight::from_parts(121_452_989, 0) - // Standard Error: 390_540 - .saturating_add(Weight::from_parts(145_641_178, 0).saturating_mul(r.into())) + // Minimum execution time: 97_873_000 picoseconds. + Weight::from_parts(159_110_710, 0) + // Standard Error: 457_822 + .saturating_add(Weight::from_parts(152_162_507, 0).saturating_mul(r.into())) } /// The range of component `n` is `[0, 8192]`. fn gr_reply_push_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 115_529_000 picoseconds. - Weight::from_parts(120_413_000, 0) - // Standard Error: 3_105 - .saturating_add(Weight::from_parts(640_863, 0).saturating_mul(n.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_reply_input(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 566_859_000 picoseconds. - Weight::from_parts(631_111_316, 0) - // Standard Error: 7_012_228 - .saturating_add(Weight::from_parts(21_896_983, 0).saturating_mul(r.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_reply_input_wgas(_r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 565_382_000 picoseconds. - Weight::from_parts(613_048_008, 0) - } - /// The range of component `r` is `[0, 1]`. - fn gr_reservation_reply(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 104_401_000 picoseconds. - Weight::from_parts(112_651_320, 0) - // Standard Error: 438_590 - .saturating_add(Weight::from_parts(11_095_379, 0).saturating_mul(r.into())) + // Minimum execution time: 112_593_000 picoseconds. + Weight::from_parts(114_913_000, 0) + // Standard Error: 2_557 + .saturating_add(Weight::from_parts(677_985, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_reservation_reply_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 115_615_000 picoseconds. - Weight::from_parts(112_987_750, 0) - // Standard Error: 960 - .saturating_add(Weight::from_parts(423_774, 0).saturating_mul(n.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_reservation_reply_commit(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 105_056_000 picoseconds. - Weight::from_parts(113_735_922, 0) - // Standard Error: 466_586 - .saturating_add(Weight::from_parts(5_305_577, 0).saturating_mul(r.into())) + // Minimum execution time: 118_073_000 picoseconds. + Weight::from_parts(113_763_795, 0) + // Standard Error: 1_010 + .saturating_add(Weight::from_parts(428_786, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_reservation_reply_commit_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 113_897_000 picoseconds. - Weight::from_parts(112_616_408, 0) - // Standard Error: 1_722 - .saturating_add(Weight::from_parts(428_420, 0).saturating_mul(n.into())) + // Minimum execution time: 114_860_000 picoseconds. + Weight::from_parts(101_920_439, 0) + // Standard Error: 1_083 + .saturating_add(Weight::from_parts(442_833, 0).saturating_mul(n.into())) } /// The range of component `r` is `[0, 20]`. fn gr_reply_to(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 93_845_000 picoseconds. - Weight::from_parts(97_247_314, 0) - // Standard Error: 366_814 - .saturating_add(Weight::from_parts(85_900_587, 0).saturating_mul(r.into())) + // Minimum execution time: 98_512_000 picoseconds. + Weight::from_parts(88_626_388, 0) + // Standard Error: 366_499 + .saturating_add(Weight::from_parts(88_122_315, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_signal_code(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 99_671_000 picoseconds. - Weight::from_parts(92_224_076, 0) - // Standard Error: 324_122 - .saturating_add(Weight::from_parts(85_769_450, 0).saturating_mul(r.into())) + // Minimum execution time: 100_944_000 picoseconds. + Weight::from_parts(94_274_573, 0) + // Standard Error: 344_379 + .saturating_add(Weight::from_parts(83_385_159, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_signal_from(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 100_099_000 picoseconds. - Weight::from_parts(93_778_262, 0) - // Standard Error: 323_481 - .saturating_add(Weight::from_parts(87_801_615, 0).saturating_mul(r.into())) + // Minimum execution time: 98_736_000 picoseconds. + Weight::from_parts(102_598_887, 0) + // Standard Error: 254_019 + .saturating_add(Weight::from_parts(86_050_309, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_reply_push_input(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 565_388_000 picoseconds. - Weight::from_parts(606_358_854, 0) - // Standard Error: 430_766 - .saturating_add(Weight::from_parts(108_769_267, 0).saturating_mul(r.into())) + // Minimum execution time: 740_156_000 picoseconds. + Weight::from_parts(781_820_116, 0) + // Standard Error: 419_407 + .saturating_add(Weight::from_parts(107_969_773, 0).saturating_mul(r.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_reply_push_input_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 591_660_000 picoseconds. - Weight::from_parts(597_035_528, 0) - // Standard Error: 2_641 - .saturating_add(Weight::from_parts(153_781, 0).saturating_mul(n.into())) + // Minimum execution time: 755_846_000 picoseconds. + Weight::from_parts(780_455_697, 0) + // Standard Error: 1_995 + .saturating_add(Weight::from_parts(161_261, 0).saturating_mul(n.into())) } /// The range of component `r` is `[0, 20]`. fn gr_send_push_input(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_317_147_000 picoseconds. - Weight::from_parts(2_514_940_964, 0) - // Standard Error: 546_319 - .saturating_add(Weight::from_parts(128_825_542, 0).saturating_mul(r.into())) + // Minimum execution time: 2_511_608_000 picoseconds. + Weight::from_parts(2_705_076_651, 0) + // Standard Error: 493_983 + .saturating_add(Weight::from_parts(127_194_997, 0).saturating_mul(r.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_send_push_input_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_560_344_000 picoseconds. - Weight::from_parts(2_512_409_449, 0) - // Standard Error: 15_466 - .saturating_add(Weight::from_parts(12_395_144, 0).saturating_mul(n.into())) + // Minimum execution time: 2_717_264_000 picoseconds. + Weight::from_parts(2_814_539_958, 0) + // Standard Error: 10_103 + .saturating_add(Weight::from_parts(13_630_637, 0).saturating_mul(n.into())) } /// The range of component `r` is `[0, 20]`. fn gr_debug(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 97_996_000 picoseconds. - Weight::from_parts(130_630_238, 0) - // Standard Error: 414_418 - .saturating_add(Weight::from_parts(114_735_577, 0).saturating_mul(r.into())) + // Minimum execution time: 97_818_000 picoseconds. + Weight::from_parts(112_676_264, 0) + // Standard Error: 333_130 + .saturating_add(Weight::from_parts(114_231_920, 0).saturating_mul(r.into())) } /// The range of component `n` is `[0, 2048]`. fn gr_debug_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 157_513_000 picoseconds. - Weight::from_parts(160_584_000, 0) - // Standard Error: 57_227 - .saturating_add(Weight::from_parts(25_738_939, 0).saturating_mul(n.into())) + // Minimum execution time: 159_849_000 picoseconds. + Weight::from_parts(161_376_000, 0) + // Standard Error: 52_546 + .saturating_add(Weight::from_parts(25_816_075, 0).saturating_mul(n.into())) } /// The range of component `r` is `[0, 20]`. fn gr_reply_code(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 92_652_000 picoseconds. - Weight::from_parts(88_138_429, 0) - // Standard Error: 330_537 - .saturating_add(Weight::from_parts(83_235_234, 0).saturating_mul(r.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_exit(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 93_824_000 picoseconds. - Weight::from_parts(102_740_497, 0) - // Standard Error: 428_593 - .saturating_add(Weight::from_parts(23_682_102, 0).saturating_mul(r.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_leave(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 92_530_000 picoseconds. - Weight::from_parts(101_410_861, 0) - // Standard Error: 432_236 - .saturating_add(Weight::from_parts(12_196_938, 0).saturating_mul(r.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_wait(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 93_402_000 picoseconds. - Weight::from_parts(102_285_877, 0) - // Standard Error: 466_463 - .saturating_add(Weight::from_parts(13_156_522, 0).saturating_mul(r.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_wait_for(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 95_706_000 picoseconds. - Weight::from_parts(102_513_059, 0) - // Standard Error: 464_787 - .saturating_add(Weight::from_parts(13_986_540, 0).saturating_mul(r.into())) - } - /// The range of component `r` is `[0, 1]`. - fn gr_wait_up_to(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 93_057_000 picoseconds. - Weight::from_parts(99_083_869, 0) - // Standard Error: 378_747 - .saturating_add(Weight::from_parts(12_230_330, 0).saturating_mul(r.into())) + // Minimum execution time: 98_916_000 picoseconds. + Weight::from_parts(92_228_268, 0) + // Standard Error: 329_307 + .saturating_add(Weight::from_parts(83_076_033, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_wake(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 177_947_000 picoseconds. - Weight::from_parts(226_692_243, 0) - // Standard Error: 265_725 - .saturating_add(Weight::from_parts(156_938_838, 0).saturating_mul(r.into())) + // Minimum execution time: 179_446_000 picoseconds. + Weight::from_parts(229_514_451, 0) + // Standard Error: 257_645 + .saturating_add(Weight::from_parts(154_731_264, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 20]`. fn gr_create_program(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 107_346_000 picoseconds. - Weight::from_parts(160_631_540, 0) - // Standard Error: 352_753 - .saturating_add(Weight::from_parts(338_685_448, 0).saturating_mul(r.into())) + // Minimum execution time: 107_616_000 picoseconds. + Weight::from_parts(175_768_720, 0) + // Standard Error: 367_635 + .saturating_add(Weight::from_parts(358_564_932, 0).saturating_mul(r.into())) } /// The range of component `p` is `[0, 2048]`. /// The range of component `s` is `[1, 2048]`. @@ -3040,22 +3044,22 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 44_754_074_000 picoseconds. - Weight::from_parts(44_833_050_000, 0) - // Standard Error: 269_308 - .saturating_add(Weight::from_parts(7_629_892, 0).saturating_mul(p.into())) - // Standard Error: 269_294 - .saturating_add(Weight::from_parts(179_148_245, 0).saturating_mul(s.into())) + // Minimum execution time: 44_902_420_000 picoseconds. + Weight::from_parts(45_126_501_000, 0) + // Standard Error: 280_708 + .saturating_add(Weight::from_parts(7_774_529, 0).saturating_mul(p.into())) + // Standard Error: 280_694 + .saturating_add(Weight::from_parts(175_731_776, 0).saturating_mul(s.into())) } /// The range of component `r` is `[0, 20]`. fn gr_create_program_wgas(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 108_278_000 picoseconds. - Weight::from_parts(161_208_126, 0) - // Standard Error: 368_644 - .saturating_add(Weight::from_parts(346_324_329, 0).saturating_mul(r.into())) + // Minimum execution time: 108_285_000 picoseconds. + Weight::from_parts(176_429_268, 0) + // Standard Error: 384_072 + .saturating_add(Weight::from_parts(366_592_077, 0).saturating_mul(r.into())) } /// The range of component `p` is `[0, 2048]`. /// The range of component `s` is `[1, 2048]`. @@ -3063,32 +3067,32 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 44_266_209_000 picoseconds. - Weight::from_parts(44_559_345_000, 0) - // Standard Error: 270_420 - .saturating_add(Weight::from_parts(7_460_172, 0).saturating_mul(p.into())) - // Standard Error: 270_407 - .saturating_add(Weight::from_parts(179_211_260, 0).saturating_mul(s.into())) + // Minimum execution time: 46_638_288_000 picoseconds. + Weight::from_parts(47_081_319_000, 0) + // Standard Error: 280_733 + .saturating_add(Weight::from_parts(7_134_527, 0).saturating_mul(p.into())) + // Standard Error: 280_720 + .saturating_add(Weight::from_parts(175_082_854, 0).saturating_mul(s.into())) } /// The range of component `r` is `[0, 20]`. fn gr_pay_program_rent(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 94_889_000 picoseconds. - Weight::from_parts(115_310_524, 0) - // Standard Error: 34_049 - .saturating_add(Weight::from_parts(1_916_607, 0).saturating_mul(r.into())) + // Minimum execution time: 100_230_000 picoseconds. + Weight::from_parts(120_175_562, 0) + // Standard Error: 35_806 + .saturating_add(Weight::from_parts(1_783_612, 0).saturating_mul(r.into())) } /// The range of component `p` is `[0, 512]`. fn lazy_pages_signal_read(p: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `141` // Estimated: `1131 + p * (9900 ±0)` - // Minimum execution time: 97_825_000 picoseconds. - Weight::from_parts(251_440_245, 1131) - // Standard Error: 70_641 - .saturating_add(Weight::from_parts(15_652_952, 0).saturating_mul(p.into())) + // Minimum execution time: 99_162_000 picoseconds. + Weight::from_parts(112_460_979, 1131) + // Standard Error: 19_215 + .saturating_add(Weight::from_parts(16_485_170, 0).saturating_mul(p.into())) .saturating_add(RocksDbWeight::get().reads((4_u64).saturating_mul(p.into()))) .saturating_add(Weight::from_parts(0, 9900).saturating_mul(p.into())) } @@ -3097,10 +3101,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `141` // Estimated: `1131 + p * (9900 ±0)` - // Minimum execution time: 96_761_000 picoseconds. - Weight::from_parts(100_398_000, 1131) - // Standard Error: 45_532 - .saturating_add(Weight::from_parts(39_790_625, 0).saturating_mul(p.into())) + // Minimum execution time: 100_684_000 picoseconds. + Weight::from_parts(104_531_000, 1131) + // Standard Error: 46_782 + .saturating_add(Weight::from_parts(42_067_142, 0).saturating_mul(p.into())) .saturating_add(RocksDbWeight::get().reads((4_u64).saturating_mul(p.into()))) .saturating_add(Weight::from_parts(0, 9900).saturating_mul(p.into())) } @@ -3109,10 +3113,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `141` // Estimated: `5069931` - // Minimum execution time: 7_471_807_000 picoseconds. - Weight::from_parts(7_440_591_962, 5069931) - // Standard Error: 168_373 - .saturating_add(Weight::from_parts(40_244_359, 0).saturating_mul(p.into())) + // Minimum execution time: 8_272_424_000 picoseconds. + Weight::from_parts(8_390_589_661, 5069931) + // Standard Error: 72_393 + .saturating_add(Weight::from_parts(42_604_682, 0).saturating_mul(p.into())) .saturating_add(RocksDbWeight::get().reads(2048_u64)) } /// The range of component `p` is `[0, 512]`. @@ -3120,10 +3124,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `1813 + p * (65580 ±0)` // Estimated: `1939 + p * (75482 ±0)` - // Minimum execution time: 97_303_000 picoseconds. - Weight::from_parts(98_185_000, 1939) - // Standard Error: 38_471 - .saturating_add(Weight::from_parts(55_016_921, 0).saturating_mul(p.into())) + // Minimum execution time: 105_024_000 picoseconds. + Weight::from_parts(106_386_000, 1939) + // Standard Error: 32_440 + .saturating_add(Weight::from_parts(54_183_902, 0).saturating_mul(p.into())) .saturating_add(RocksDbWeight::get().reads((4_u64).saturating_mul(p.into()))) .saturating_add(Weight::from_parts(0, 75482).saturating_mul(p.into())) } @@ -3132,10 +3136,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `141` // Estimated: `1131 + p * (9900 ±0)` - // Minimum execution time: 102_497_000 picoseconds. - Weight::from_parts(104_932_685, 1131) - // Standard Error: 78_974 - .saturating_add(Weight::from_parts(39_257_150, 0).saturating_mul(p.into())) + // Minimum execution time: 102_854_000 picoseconds. + Weight::from_parts(109_646_367, 1131) + // Standard Error: 70_655 + .saturating_add(Weight::from_parts(39_228_760, 0).saturating_mul(p.into())) .saturating_add(RocksDbWeight::get().reads((4_u64).saturating_mul(p.into()))) .saturating_add(Weight::from_parts(0, 9900).saturating_mul(p.into())) } @@ -3144,10 +3148,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `141` // Estimated: `1496 + p * (9883 ±2)` - // Minimum execution time: 612_308_000 picoseconds. - Weight::from_parts(642_079_999, 1496) - // Standard Error: 357_245 - .saturating_add(Weight::from_parts(46_518_860, 0).saturating_mul(p.into())) + // Minimum execution time: 761_606_000 picoseconds. + Weight::from_parts(762_350_763, 1496) + // Standard Error: 286_780 + .saturating_add(Weight::from_parts(50_979_584, 0).saturating_mul(p.into())) .saturating_add(RocksDbWeight::get().reads((4_u64).saturating_mul(p.into()))) .saturating_add(Weight::from_parts(0, 9883).saturating_mul(p.into())) } @@ -3156,10 +3160,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `141` // Estimated: `317931` - // Minimum execution time: 1_068_248_000 picoseconds. - Weight::from_parts(1_080_741_205, 317931) - // Standard Error: 262_216 - .saturating_add(Weight::from_parts(50_047_907, 0).saturating_mul(p.into())) + // Minimum execution time: 1_256_343_000 picoseconds. + Weight::from_parts(1_302_047_252, 317931) + // Standard Error: 283_008 + .saturating_add(Weight::from_parts(47_678_236, 0).saturating_mul(p.into())) .saturating_add(RocksDbWeight::get().reads(128_u64)) } /// The range of component `r` is `[0, 20]`. @@ -3167,603 +3171,603 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 3_099_000 picoseconds. - Weight::from_parts(6_340_084, 0) - // Standard Error: 180_257 - .saturating_add(Weight::from_parts(74_666_091, 0).saturating_mul(r.into())) + // Minimum execution time: 4_405_000 picoseconds. + Weight::from_parts(16_352_957, 0) + // Standard Error: 351_237 + .saturating_add(Weight::from_parts(74_154_815, 0).saturating_mul(r.into())) } /// The range of component `r` is `[50, 500]`. fn instr_i64load(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 4_391_547_000 picoseconds. - Weight::from_parts(4_140_785_425, 0) - // Standard Error: 89_369 - .saturating_add(Weight::from_parts(5_769_622, 0).saturating_mul(r.into())) + // Minimum execution time: 4_441_407_000 picoseconds. + Weight::from_parts(4_242_069_387, 0) + // Standard Error: 107_408 + .saturating_add(Weight::from_parts(5_267_383, 0).saturating_mul(r.into())) } /// The range of component `r` is `[50, 500]`. fn instr_i32load(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 4_386_802_000 picoseconds. - Weight::from_parts(4_243_536_456, 0) - // Standard Error: 95_210 - .saturating_add(Weight::from_parts(5_278_131, 0).saturating_mul(r.into())) + // Minimum execution time: 4_473_808_000 picoseconds. + Weight::from_parts(4_245_461_153, 0) + // Standard Error: 115_662 + .saturating_add(Weight::from_parts(5_334_771, 0).saturating_mul(r.into())) } /// The range of component `r` is `[50, 500]`. fn instr_i64store(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 11_072_272_000 picoseconds. - Weight::from_parts(11_558_306_225, 0) - // Standard Error: 165_659 - .saturating_add(Weight::from_parts(9_828_260, 0).saturating_mul(r.into())) + // Minimum execution time: 11_011_360_000 picoseconds. + Weight::from_parts(11_931_421_315, 0) + // Standard Error: 187_701 + .saturating_add(Weight::from_parts(13_022_743, 0).saturating_mul(r.into())) } /// The range of component `r` is `[50, 500]`. fn instr_i32store(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 10_285_071_000 picoseconds. - Weight::from_parts(11_137_621_942, 0) - // Standard Error: 147_513 - .saturating_add(Weight::from_parts(9_014_757, 0).saturating_mul(r.into())) + // Minimum execution time: 10_664_214_000 picoseconds. + Weight::from_parts(11_902_396_905, 0) + // Standard Error: 182_715 + .saturating_add(Weight::from_parts(10_825_224, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_select(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_285_000 picoseconds. - Weight::from_parts(2_410_000, 0) - // Standard Error: 7_624 - .saturating_add(Weight::from_parts(3_864_490, 0).saturating_mul(r.into())) + // Minimum execution time: 2_372_000 picoseconds. + Weight::from_parts(2_477_000, 0) + // Standard Error: 7_020 + .saturating_add(Weight::from_parts(3_847_128, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_if(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_342_000 picoseconds. - Weight::from_parts(2_433_000, 0) - // Standard Error: 6_413 - .saturating_add(Weight::from_parts(3_120_732, 0).saturating_mul(r.into())) + // Minimum execution time: 2_352_000 picoseconds. + Weight::from_parts(470_151, 0) + // Standard Error: 9_768 + .saturating_add(Weight::from_parts(3_187_107, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_br(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_301_000 picoseconds. - Weight::from_parts(3_591_730, 0) - // Standard Error: 1_106 - .saturating_add(Weight::from_parts(1_565_415, 0).saturating_mul(r.into())) + // Minimum execution time: 2_328_000 picoseconds. + Weight::from_parts(3_603_744, 0) + // Standard Error: 1_310 + .saturating_add(Weight::from_parts(1_573_794, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_br_if(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_306_000 picoseconds. - Weight::from_parts(2_461_000, 0) - // Standard Error: 7_711 - .saturating_add(Weight::from_parts(2_932_880, 0).saturating_mul(r.into())) + // Minimum execution time: 2_406_000 picoseconds. + Weight::from_parts(2_502_000, 0) + // Standard Error: 9_218 + .saturating_add(Weight::from_parts(2_948_836, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_br_table(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_358_000 picoseconds. - Weight::from_parts(2_144_801, 0) - // Standard Error: 22_082 - .saturating_add(Weight::from_parts(5_266_139, 0).saturating_mul(r.into())) + // Minimum execution time: 2_377_000 picoseconds. + Weight::from_parts(5_774_753, 0) + // Standard Error: 20_000 + .saturating_add(Weight::from_parts(4_967_379, 0).saturating_mul(r.into())) } /// The range of component `e` is `[1, 256]`. fn instr_br_table_per_entry(e: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 6_803_000 picoseconds. - Weight::from_parts(5_374_690, 0) - // Standard Error: 1_699 - .saturating_add(Weight::from_parts(171_193, 0).saturating_mul(e.into())) + // Minimum execution time: 7_031_000 picoseconds. + Weight::from_parts(5_288_626, 0) + // Standard Error: 1_512 + .saturating_add(Weight::from_parts(180_398, 0).saturating_mul(e.into())) } /// The range of component `r` is `[0, 50]`. fn instr_call_const(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_431_000 picoseconds. - Weight::from_parts(4_875_813, 0) - // Standard Error: 8_258 - .saturating_add(Weight::from_parts(2_629_733, 0).saturating_mul(r.into())) + // Minimum execution time: 2_476_000 picoseconds. + Weight::from_parts(5_743_941, 0) + // Standard Error: 9_413 + .saturating_add(Weight::from_parts(2_620_325, 0).saturating_mul(r.into())) } fn instr_i64const(r: u32, ) -> Weight { Weight::from_parts(0, 0) - .saturating_add(Weight::from_parts(2_629_733 - - 2_421_700, 0).saturating_mul(r.into())) + .saturating_add(Weight::from_parts(2_620_325 - + 2_411_747, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_call(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_403_000 picoseconds. - Weight::from_parts(5_140_243, 0) - // Standard Error: 13_164 - .saturating_add(Weight::from_parts(2_421_700, 0).saturating_mul(r.into())) + // Minimum execution time: 2_490_000 picoseconds. + Weight::from_parts(6_164_933, 0) + // Standard Error: 13_627 + .saturating_add(Weight::from_parts(2_411_747, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_call_indirect(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_669_000 picoseconds. - Weight::from_parts(22_369_265, 0) - // Standard Error: 28_577 - .saturating_add(Weight::from_parts(9_740_558, 0).saturating_mul(r.into())) + // Minimum execution time: 2_755_000 picoseconds. + Weight::from_parts(21_073_006, 0) + // Standard Error: 27_772 + .saturating_add(Weight::from_parts(9_843_221, 0).saturating_mul(r.into())) } /// The range of component `p` is `[0, 128]`. fn instr_call_indirect_per_param(p: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 12_277_000 picoseconds. - Weight::from_parts(3_596_853, 0) - // Standard Error: 5_869 - .saturating_add(Weight::from_parts(1_258_605, 0).saturating_mul(p.into())) + // Minimum execution time: 12_641_000 picoseconds. + Weight::from_parts(3_862_091, 0) + // Standard Error: 6_388 + .saturating_add(Weight::from_parts(1_271_540, 0).saturating_mul(p.into())) } /// The range of component `l` is `[0, 1024]`. fn instr_call_per_local(_l: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 5_391_000 picoseconds. - Weight::from_parts(5_778_137, 0) + // Minimum execution time: 5_445_000 picoseconds. + Weight::from_parts(5_936_643, 0) } /// The range of component `r` is `[0, 50]`. fn instr_local_get(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 4_835_000 picoseconds. - Weight::from_parts(6_065_483, 0) - // Standard Error: 3_006 - .saturating_add(Weight::from_parts(378_512, 0).saturating_mul(r.into())) + // Minimum execution time: 4_780_000 picoseconds. + Weight::from_parts(5_168_488, 0) + // Standard Error: 3_624 + .saturating_add(Weight::from_parts(434_517, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_local_set(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 4_722_000 picoseconds. - Weight::from_parts(3_902_309, 0) - // Standard Error: 5_742 - .saturating_add(Weight::from_parts(1_056_408, 0).saturating_mul(r.into())) + // Minimum execution time: 4_903_000 picoseconds. + Weight::from_parts(4_238_955, 0) + // Standard Error: 7_038 + .saturating_add(Weight::from_parts(1_087_596, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_local_tee(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 4_888_000 picoseconds. - Weight::from_parts(4_512_058, 0) - // Standard Error: 6_410 - .saturating_add(Weight::from_parts(1_001_510, 0).saturating_mul(r.into())) + // Minimum execution time: 4_937_000 picoseconds. + Weight::from_parts(3_461_941, 0) + // Standard Error: 7_961 + .saturating_add(Weight::from_parts(1_107_695, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_global_get(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 6_413_000 picoseconds. - Weight::from_parts(2_704_134, 0) - // Standard Error: 7_244 - .saturating_add(Weight::from_parts(804_200, 0).saturating_mul(r.into())) + // Minimum execution time: 6_601_000 picoseconds. + Weight::from_parts(2_918_352, 0) + // Standard Error: 7_206 + .saturating_add(Weight::from_parts(827_628, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_global_set(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 6_516_000 picoseconds. - Weight::from_parts(1_028_752, 0) - // Standard Error: 8_792 - .saturating_add(Weight::from_parts(1_494_630, 0).saturating_mul(r.into())) + // Minimum execution time: 6_605_000 picoseconds. + Weight::from_parts(6_684_000, 0) + // Standard Error: 8_000 + .saturating_add(Weight::from_parts(1_428_490, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_memory_current(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 5_560_000 picoseconds. - Weight::from_parts(1_126_442, 0) - // Standard Error: 14_476 - .saturating_add(Weight::from_parts(7_240_597, 0).saturating_mul(r.into())) + // Minimum execution time: 7_591_000 picoseconds. + Weight::from_parts(2_772_486, 0) + // Standard Error: 13_130 + .saturating_add(Weight::from_parts(7_127_049, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64clz(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_299_000 picoseconds. - Weight::from_parts(2_449_000, 0) - // Standard Error: 7_416 - .saturating_add(Weight::from_parts(3_344_387, 0).saturating_mul(r.into())) + // Minimum execution time: 2_376_000 picoseconds. + Weight::from_parts(2_431_000, 0) + // Standard Error: 6_471 + .saturating_add(Weight::from_parts(3_416_623, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32clz(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_389_000 picoseconds. - Weight::from_parts(2_551_000, 0) - // Standard Error: 5_708 - .saturating_add(Weight::from_parts(3_133_430, 0).saturating_mul(r.into())) + // Minimum execution time: 2_367_000 picoseconds. + Weight::from_parts(2_481_000, 0) + // Standard Error: 4_834 + .saturating_add(Weight::from_parts(3_141_274, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64ctz(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_428_000 picoseconds. - Weight::from_parts(2_511_000, 0) - // Standard Error: 7_262 - .saturating_add(Weight::from_parts(3_192_675, 0).saturating_mul(r.into())) + // Minimum execution time: 2_414_000 picoseconds. + Weight::from_parts(2_479_000, 0) + // Standard Error: 5_384 + .saturating_add(Weight::from_parts(3_162_450, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32ctz(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_333_000 picoseconds. - Weight::from_parts(2_426_000, 0) - // Standard Error: 4_554 - .saturating_add(Weight::from_parts(2_683_293, 0).saturating_mul(r.into())) + // Minimum execution time: 2_481_000 picoseconds. + Weight::from_parts(2_534_000, 0) + // Standard Error: 5_851 + .saturating_add(Weight::from_parts(2_742_009, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64popcnt(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_334_000 picoseconds. - Weight::from_parts(2_385_000, 0) - // Standard Error: 4_686 - .saturating_add(Weight::from_parts(631_609, 0).saturating_mul(r.into())) + // Minimum execution time: 2_444_000 picoseconds. + Weight::from_parts(2_522_000, 0) + // Standard Error: 5_551 + .saturating_add(Weight::from_parts(650_966, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32popcnt(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_356_000 picoseconds. - Weight::from_parts(1_221_890, 0) - // Standard Error: 3_960 - .saturating_add(Weight::from_parts(452_047, 0).saturating_mul(r.into())) + // Minimum execution time: 2_476_000 picoseconds. + Weight::from_parts(627_113, 0) + // Standard Error: 6_633 + .saturating_add(Weight::from_parts(527_272, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64eqz(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_318_000 picoseconds. - Weight::from_parts(2_390_000, 0) - // Standard Error: 11_114 - .saturating_add(Weight::from_parts(1_916_122, 0).saturating_mul(r.into())) + // Minimum execution time: 2_415_000 picoseconds. + Weight::from_parts(2_511_000, 0) + // Standard Error: 10_855 + .saturating_add(Weight::from_parts(1_987_179, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32eqz(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_436_000 picoseconds. - Weight::from_parts(2_504_000, 0) - // Standard Error: 7_104 - .saturating_add(Weight::from_parts(1_156_958, 0).saturating_mul(r.into())) + // Minimum execution time: 2_374_000 picoseconds. + Weight::from_parts(2_523_000, 0) + // Standard Error: 8_639 + .saturating_add(Weight::from_parts(1_265_345, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32extend8s(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_276_000 picoseconds. - Weight::from_parts(1_708_596, 0) - // Standard Error: 2_843 - .saturating_add(Weight::from_parts(377_083, 0).saturating_mul(r.into())) + // Minimum execution time: 2_385_000 picoseconds. + Weight::from_parts(1_218_539, 0) + // Standard Error: 5_119 + .saturating_add(Weight::from_parts(443_968, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32extend16s(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_386_000 picoseconds. - Weight::from_parts(1_424_415, 0) - // Standard Error: 3_599 - .saturating_add(Weight::from_parts(395_934, 0).saturating_mul(r.into())) + // Minimum execution time: 2_408_000 picoseconds. + Weight::from_parts(1_419_491, 0) + // Standard Error: 3_971 + .saturating_add(Weight::from_parts(429_566, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64extend8s(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_396_000 picoseconds. - Weight::from_parts(2_491_000, 0) - // Standard Error: 3_774 - .saturating_add(Weight::from_parts(516_281, 0).saturating_mul(r.into())) + // Minimum execution time: 2_442_000 picoseconds. + Weight::from_parts(2_534_000, 0) + // Standard Error: 5_488 + .saturating_add(Weight::from_parts(626_359, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64extend16s(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_308_000 picoseconds. - Weight::from_parts(548_192, 0) - // Standard Error: 4_583 - .saturating_add(Weight::from_parts(556_734, 0).saturating_mul(r.into())) + // Minimum execution time: 2_383_000 picoseconds. + Weight::from_parts(267_997, 0) + // Standard Error: 6_829 + .saturating_add(Weight::from_parts(639_304, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64extend32s(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_333_000 picoseconds. - Weight::from_parts(447_271, 0) - // Standard Error: 5_300 - .saturating_add(Weight::from_parts(535_915, 0).saturating_mul(r.into())) + // Minimum execution time: 2_336_000 picoseconds. + Weight::from_parts(2_524_000, 0) + // Standard Error: 4_090 + .saturating_add(Weight::from_parts(515_493, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64extendsi32(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_340_000 picoseconds. - Weight::from_parts(1_639_695, 0) - // Standard Error: 3_519 - .saturating_add(Weight::from_parts(368_523, 0).saturating_mul(r.into())) + // Minimum execution time: 2_419_000 picoseconds. + Weight::from_parts(1_479_176, 0) + // Standard Error: 4_590 + .saturating_add(Weight::from_parts(393_408, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64extendui32(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_305_000 picoseconds. - Weight::from_parts(2_843_474, 0) - // Standard Error: 1_950 - .saturating_add(Weight::from_parts(176_592, 0).saturating_mul(r.into())) + // Minimum execution time: 2_404_000 picoseconds. + Weight::from_parts(2_886_191, 0) + // Standard Error: 2_108 + .saturating_add(Weight::from_parts(180_952, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32wrapi64(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_351_000 picoseconds. - Weight::from_parts(2_894_613, 0) - // Standard Error: 2_024 - .saturating_add(Weight::from_parts(188_853, 0).saturating_mul(r.into())) + // Minimum execution time: 2_423_000 picoseconds. + Weight::from_parts(2_587_480, 0) + // Standard Error: 2_350 + .saturating_add(Weight::from_parts(202_312, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64eq(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_353_000 picoseconds. - Weight::from_parts(2_418_000, 0) - // Standard Error: 9_504 - .saturating_add(Weight::from_parts(1_936_605, 0).saturating_mul(r.into())) + // Minimum execution time: 2_457_000 picoseconds. + Weight::from_parts(2_558_000, 0) + // Standard Error: 9_756 + .saturating_add(Weight::from_parts(1_914_693, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32eq(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_291_000 picoseconds. - Weight::from_parts(2_364_000, 0) - // Standard Error: 8_346 - .saturating_add(Weight::from_parts(1_222_521, 0).saturating_mul(r.into())) + // Minimum execution time: 2_431_000 picoseconds. + Weight::from_parts(2_481_000, 0) + // Standard Error: 8_683 + .saturating_add(Weight::from_parts(1_235_014, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64ne(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_345_000 picoseconds. - Weight::from_parts(2_452_000, 0) - // Standard Error: 10_232 - .saturating_add(Weight::from_parts(1_883_867, 0).saturating_mul(r.into())) + // Minimum execution time: 2_418_000 picoseconds. + Weight::from_parts(2_533_000, 0) + // Standard Error: 9_762 + .saturating_add(Weight::from_parts(1_952_043, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32ne(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_323_000 picoseconds. - Weight::from_parts(2_387_000, 0) - // Standard Error: 7_581 - .saturating_add(Weight::from_parts(1_200_178, 0).saturating_mul(r.into())) + // Minimum execution time: 2_444_000 picoseconds. + Weight::from_parts(2_542_000, 0) + // Standard Error: 8_692 + .saturating_add(Weight::from_parts(1_240_320, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64lts(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_410_000 picoseconds. - Weight::from_parts(2_459_000, 0) - // Standard Error: 11_139 - .saturating_add(Weight::from_parts(1_877_766, 0).saturating_mul(r.into())) + // Minimum execution time: 2_415_000 picoseconds. + Weight::from_parts(2_535_000, 0) + // Standard Error: 10_660 + .saturating_add(Weight::from_parts(1_944_040, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32lts(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_273_000 picoseconds. - Weight::from_parts(2_387_000, 0) - // Standard Error: 8_083 - .saturating_add(Weight::from_parts(1_217_904, 0).saturating_mul(r.into())) + // Minimum execution time: 2_365_000 picoseconds. + Weight::from_parts(2_469_000, 0) + // Standard Error: 7_760 + .saturating_add(Weight::from_parts(1_232_925, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64ltu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_403_000 picoseconds. - Weight::from_parts(2_482_000, 0) - // Standard Error: 11_044 - .saturating_add(Weight::from_parts(1_956_302, 0).saturating_mul(r.into())) + // Minimum execution time: 2_445_000 picoseconds. + Weight::from_parts(2_496_000, 0) + // Standard Error: 10_669 + .saturating_add(Weight::from_parts(1_917_582, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32ltu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_353_000 picoseconds. - Weight::from_parts(2_420_000, 0) - // Standard Error: 7_870 - .saturating_add(Weight::from_parts(1_213_570, 0).saturating_mul(r.into())) + // Minimum execution time: 2_393_000 picoseconds. + Weight::from_parts(2_455_000, 0) + // Standard Error: 8_096 + .saturating_add(Weight::from_parts(1_210_306, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64gts(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_364_000 picoseconds. - Weight::from_parts(2_430_000, 0) - // Standard Error: 10_577 - .saturating_add(Weight::from_parts(1_968_043, 0).saturating_mul(r.into())) + // Minimum execution time: 2_351_000 picoseconds. + Weight::from_parts(2_463_000, 0) + // Standard Error: 10_885 + .saturating_add(Weight::from_parts(1_890_425, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32gts(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_328_000 picoseconds. - Weight::from_parts(2_442_000, 0) - // Standard Error: 7_838 - .saturating_add(Weight::from_parts(1_267_211, 0).saturating_mul(r.into())) + // Minimum execution time: 2_460_000 picoseconds. + Weight::from_parts(2_542_000, 0) + // Standard Error: 9_229 + .saturating_add(Weight::from_parts(1_236_149, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64gtu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_395_000 picoseconds. - Weight::from_parts(2_460_000, 0) - // Standard Error: 10_856 - .saturating_add(Weight::from_parts(1_910_357, 0).saturating_mul(r.into())) + // Minimum execution time: 2_438_000 picoseconds. + Weight::from_parts(2_519_000, 0) + // Standard Error: 10_023 + .saturating_add(Weight::from_parts(1_937_593, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32gtu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_343_000 picoseconds. - Weight::from_parts(2_409_000, 0) - // Standard Error: 5_786 - .saturating_add(Weight::from_parts(1_128_653, 0).saturating_mul(r.into())) + // Minimum execution time: 2_414_000 picoseconds. + Weight::from_parts(2_509_000, 0) + // Standard Error: 8_360 + .saturating_add(Weight::from_parts(1_234_039, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64les(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_318_000 picoseconds. - Weight::from_parts(2_433_000, 0) - // Standard Error: 10_344 - .saturating_add(Weight::from_parts(1_897_480, 0).saturating_mul(r.into())) + // Minimum execution time: 2_354_000 picoseconds. + Weight::from_parts(2_409_000, 0) + // Standard Error: 10_328 + .saturating_add(Weight::from_parts(1_926_867, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32les(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_355_000 picoseconds. - Weight::from_parts(2_460_000, 0) - // Standard Error: 6_963 - .saturating_add(Weight::from_parts(1_125_698, 0).saturating_mul(r.into())) + // Minimum execution time: 2_404_000 picoseconds. + Weight::from_parts(2_498_000, 0) + // Standard Error: 6_744 + .saturating_add(Weight::from_parts(1_201_302, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64leu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_356_000 picoseconds. - Weight::from_parts(2_447_000, 0) - // Standard Error: 8_285 - .saturating_add(Weight::from_parts(1_848_149, 0).saturating_mul(r.into())) + // Minimum execution time: 2_410_000 picoseconds. + Weight::from_parts(2_483_000, 0) + // Standard Error: 9_487 + .saturating_add(Weight::from_parts(1_900_378, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32leu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_327_000 picoseconds. - Weight::from_parts(2_394_000, 0) - // Standard Error: 7_282 - .saturating_add(Weight::from_parts(1_176_423, 0).saturating_mul(r.into())) + // Minimum execution time: 2_387_000 picoseconds. + Weight::from_parts(2_459_000, 0) + // Standard Error: 7_524 + .saturating_add(Weight::from_parts(1_246_740, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64ges(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_372_000 picoseconds. - Weight::from_parts(2_439_000, 0) - // Standard Error: 9_207 - .saturating_add(Weight::from_parts(1_837_009, 0).saturating_mul(r.into())) + // Minimum execution time: 2_452_000 picoseconds. + Weight::from_parts(2_532_000, 0) + // Standard Error: 9_466 + .saturating_add(Weight::from_parts(1_877_147, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32ges(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_368_000 picoseconds. - Weight::from_parts(2_427_000, 0) - // Standard Error: 8_320 - .saturating_add(Weight::from_parts(1_231_088, 0).saturating_mul(r.into())) + // Minimum execution time: 2_374_000 picoseconds. + Weight::from_parts(2_541_000, 0) + // Standard Error: 8_268 + .saturating_add(Weight::from_parts(1_218_632, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64geu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_373_000 picoseconds. - Weight::from_parts(2_461_000, 0) - // Standard Error: 9_499 - .saturating_add(Weight::from_parts(1_922_588, 0).saturating_mul(r.into())) + // Minimum execution time: 2_393_000 picoseconds. + Weight::from_parts(2_485_000, 0) + // Standard Error: 9_288 + .saturating_add(Weight::from_parts(1_892_308, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32geu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_387_000 picoseconds. - Weight::from_parts(2_455_000, 0) - // Standard Error: 7_681 - .saturating_add(Weight::from_parts(1_198_894, 0).saturating_mul(r.into())) + // Minimum execution time: 2_416_000 picoseconds. + Weight::from_parts(2_490_000, 0) + // Standard Error: 7_514 + .saturating_add(Weight::from_parts(1_221_546, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64add(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_308_000 picoseconds. - Weight::from_parts(2_389_000, 0) - // Standard Error: 7_797 - .saturating_add(Weight::from_parts(1_286_566, 0).saturating_mul(r.into())) + // Minimum execution time: 2_396_000 picoseconds. + Weight::from_parts(2_479_000, 0) + // Standard Error: 8_638 + .saturating_add(Weight::from_parts(1_370_587, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32add(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_329_000 picoseconds. - Weight::from_parts(2_389_000, 0) - // Standard Error: 4_968 - .saturating_add(Weight::from_parts(645_254, 0).saturating_mul(r.into())) + // Minimum execution time: 2_364_000 picoseconds. + Weight::from_parts(2_433_000, 0) + // Standard Error: 7_144 + .saturating_add(Weight::from_parts(740_923, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64sub(r: u32, ) -> Weight { @@ -3771,286 +3775,286 @@ impl WeightInfo for () { // Measured: `0` // Estimated: `0` // Minimum execution time: 2_409_000 picoseconds. - Weight::from_parts(2_489_000, 0) - // Standard Error: 7_055 - .saturating_add(Weight::from_parts(1_232_084, 0).saturating_mul(r.into())) + Weight::from_parts(2_490_000, 0) + // Standard Error: 7_493 + .saturating_add(Weight::from_parts(1_344_150, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32sub(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_371_000 picoseconds. - Weight::from_parts(2_420_000, 0) - // Standard Error: 4_348 - .saturating_add(Weight::from_parts(633_810, 0).saturating_mul(r.into())) + // Minimum execution time: 2_332_000 picoseconds. + Weight::from_parts(2_408_000, 0) + // Standard Error: 5_062 + .saturating_add(Weight::from_parts(682_810, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64mul(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_336_000 picoseconds. - Weight::from_parts(2_413_000, 0) - // Standard Error: 8_202 - .saturating_add(Weight::from_parts(1_777_425, 0).saturating_mul(r.into())) + // Minimum execution time: 2_357_000 picoseconds. + Weight::from_parts(2_429_000, 0) + // Standard Error: 8_825 + .saturating_add(Weight::from_parts(1_852_934, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32mul(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_314_000 picoseconds. - Weight::from_parts(2_369_000, 0) - // Standard Error: 6_935 - .saturating_add(Weight::from_parts(1_201_570, 0).saturating_mul(r.into())) + // Minimum execution time: 2_379_000 picoseconds. + Weight::from_parts(2_477_000, 0) + // Standard Error: 7_950 + .saturating_add(Weight::from_parts(1_310_475, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64divs(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_276_000 picoseconds. - Weight::from_parts(6_846_840, 0) - // Standard Error: 17_822 - .saturating_add(Weight::from_parts(2_268_370, 0).saturating_mul(r.into())) + // Minimum execution time: 2_486_000 picoseconds. + Weight::from_parts(7_409_149, 0) + // Standard Error: 23_280 + .saturating_add(Weight::from_parts(2_380_599, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32divs(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_394_000 picoseconds. - Weight::from_parts(4_704_336, 0) - // Standard Error: 10_960 - .saturating_add(Weight::from_parts(2_182_711, 0).saturating_mul(r.into())) + // Minimum execution time: 2_354_000 picoseconds. + Weight::from_parts(3_985_947, 0) + // Standard Error: 17_253 + .saturating_add(Weight::from_parts(2_308_046, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64divu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_375_000 picoseconds. - Weight::from_parts(1_968_824, 0) - // Standard Error: 15_899 - .saturating_add(Weight::from_parts(2_762_269, 0).saturating_mul(r.into())) + // Minimum execution time: 2_428_000 picoseconds. + Weight::from_parts(5_185_413, 0) + // Standard Error: 23_626 + .saturating_add(Weight::from_parts(2_773_914, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32divu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_335_000 picoseconds. - Weight::from_parts(1_450_000, 0) - // Standard Error: 13_496 - .saturating_add(Weight::from_parts(2_401_407, 0).saturating_mul(r.into())) + // Minimum execution time: 2_429_000 picoseconds. + Weight::from_parts(1_762_312, 0) + // Standard Error: 13_137 + .saturating_add(Weight::from_parts(2_479_857, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64rems(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_448_000 picoseconds. - Weight::from_parts(2_513_000, 0) - // Standard Error: 19_401 - .saturating_add(Weight::from_parts(9_309_211, 0).saturating_mul(r.into())) + // Minimum execution time: 2_409_000 picoseconds. + Weight::from_parts(6_183_774, 0) + // Standard Error: 38_390 + .saturating_add(Weight::from_parts(9_036_753, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32rems(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_273_000 picoseconds. - Weight::from_parts(1_738_370, 0) - // Standard Error: 42_672 - .saturating_add(Weight::from_parts(7_512_557, 0).saturating_mul(r.into())) + // Minimum execution time: 2_365_000 picoseconds. + Weight::from_parts(4_139_889, 0) + // Standard Error: 41_118 + .saturating_add(Weight::from_parts(7_440_928, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64remu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_371_000 picoseconds. - Weight::from_parts(2_215_088, 0) - // Standard Error: 15_445 - .saturating_add(Weight::from_parts(2_956_278, 0).saturating_mul(r.into())) + // Minimum execution time: 2_381_000 picoseconds. + Weight::from_parts(6_243_134, 0) + // Standard Error: 22_183 + .saturating_add(Weight::from_parts(2_805_045, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32remu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_409_000 picoseconds. - Weight::from_parts(217_500, 0) - // Standard Error: 7_904 - .saturating_add(Weight::from_parts(2_576_151, 0).saturating_mul(r.into())) + // Minimum execution time: 2_235_000 picoseconds. + Weight::from_parts(3_471_941, 0) + // Standard Error: 17_840 + .saturating_add(Weight::from_parts(2_399_950, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64and(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_456_000 picoseconds. - Weight::from_parts(2_503_000, 0) - // Standard Error: 7_920 - .saturating_add(Weight::from_parts(1_321_543, 0).saturating_mul(r.into())) + // Minimum execution time: 2_386_000 picoseconds. + Weight::from_parts(2_442_000, 0) + // Standard Error: 9_450 + .saturating_add(Weight::from_parts(1_363_334, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32and(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_346_000 picoseconds. - Weight::from_parts(2_479_000, 0) - // Standard Error: 4_711 - .saturating_add(Weight::from_parts(689_892, 0).saturating_mul(r.into())) + // Minimum execution time: 2_344_000 picoseconds. + Weight::from_parts(2_515_000, 0) + // Standard Error: 5_086 + .saturating_add(Weight::from_parts(682_806, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64or(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_339_000 picoseconds. - Weight::from_parts(2_427_000, 0) - // Standard Error: 8_029 - .saturating_add(Weight::from_parts(1_256_838, 0).saturating_mul(r.into())) + // Minimum execution time: 2_426_000 picoseconds. + Weight::from_parts(2_542_000, 0) + // Standard Error: 9_043 + .saturating_add(Weight::from_parts(1_383_826, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32or(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_334_000 picoseconds. - Weight::from_parts(2_480_000, 0) - // Standard Error: 3_812 - .saturating_add(Weight::from_parts(607_420, 0).saturating_mul(r.into())) + // Minimum execution time: 2_462_000 picoseconds. + Weight::from_parts(2_534_000, 0) + // Standard Error: 5_704 + .saturating_add(Weight::from_parts(687_779, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64xor(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_328_000 picoseconds. - Weight::from_parts(2_392_000, 0) - // Standard Error: 7_362 - .saturating_add(Weight::from_parts(1_248_739, 0).saturating_mul(r.into())) + // Minimum execution time: 2_386_000 picoseconds. + Weight::from_parts(2_437_000, 0) + // Standard Error: 7_683 + .saturating_add(Weight::from_parts(1_343_755, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32xor(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_419_000 picoseconds. - Weight::from_parts(2_465_000, 0) - // Standard Error: 4_304 - .saturating_add(Weight::from_parts(604_813, 0).saturating_mul(r.into())) + // Minimum execution time: 2_376_000 picoseconds. + Weight::from_parts(2_482_000, 0) + // Standard Error: 4_933 + .saturating_add(Weight::from_parts(708_732, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64shl(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_298_000 picoseconds. - Weight::from_parts(2_433_000, 0) - // Standard Error: 8_043 - .saturating_add(Weight::from_parts(1_073_194, 0).saturating_mul(r.into())) + // Minimum execution time: 2_449_000 picoseconds. + Weight::from_parts(2_532_000, 0) + // Standard Error: 6_389 + .saturating_add(Weight::from_parts(1_180_854, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32shl(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_427_000 picoseconds. - Weight::from_parts(2_511_000, 0) - // Standard Error: 4_969 - .saturating_add(Weight::from_parts(594_802, 0).saturating_mul(r.into())) + // Minimum execution time: 2_349_000 picoseconds. + Weight::from_parts(2_425_000, 0) + // Standard Error: 4_313 + .saturating_add(Weight::from_parts(633_941, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64shrs(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_312_000 picoseconds. - Weight::from_parts(2_399_000, 0) - // Standard Error: 7_093 - .saturating_add(Weight::from_parts(1_110_114, 0).saturating_mul(r.into())) + // Minimum execution time: 2_467_000 picoseconds. + Weight::from_parts(2_512_000, 0) + // Standard Error: 8_780 + .saturating_add(Weight::from_parts(1_192_503, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32shrs(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_331_000 picoseconds. - Weight::from_parts(2_433_000, 0) - // Standard Error: 4_140 - .saturating_add(Weight::from_parts(600_354, 0).saturating_mul(r.into())) + // Minimum execution time: 2_527_000 picoseconds. + Weight::from_parts(2_588_000, 0) + // Standard Error: 4_176 + .saturating_add(Weight::from_parts(593_049, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64shru(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_300_000 picoseconds. - Weight::from_parts(2_419_000, 0) - // Standard Error: 7_150 - .saturating_add(Weight::from_parts(1_154_649, 0).saturating_mul(r.into())) + // Minimum execution time: 2_415_000 picoseconds. + Weight::from_parts(2_530_000, 0) + // Standard Error: 7_794 + .saturating_add(Weight::from_parts(1_154_673, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32shru(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_356_000 picoseconds. - Weight::from_parts(2_423_000, 0) - // Standard Error: 5_067 - .saturating_add(Weight::from_parts(594_487, 0).saturating_mul(r.into())) + // Minimum execution time: 2_440_000 picoseconds. + Weight::from_parts(2_524_000, 0) + // Standard Error: 5_453 + .saturating_add(Weight::from_parts(633_003, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64rotl(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_339_000 picoseconds. - Weight::from_parts(2_406_000, 0) - // Standard Error: 5_674 - .saturating_add(Weight::from_parts(1_051_819, 0).saturating_mul(r.into())) + // Minimum execution time: 2_341_000 picoseconds. + Weight::from_parts(2_378_000, 0) + // Standard Error: 8_555 + .saturating_add(Weight::from_parts(1_196_751, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32rotl(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_383_000 picoseconds. - Weight::from_parts(114_723, 0) - // Standard Error: 5_881 - .saturating_add(Weight::from_parts(646_798, 0).saturating_mul(r.into())) + // Minimum execution time: 2_395_000 picoseconds. + Weight::from_parts(2_496_000, 0) + // Standard Error: 4_682 + .saturating_add(Weight::from_parts(627_173, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64rotr(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_292_000 picoseconds. - Weight::from_parts(2_422_000, 0) - // Standard Error: 6_697 - .saturating_add(Weight::from_parts(1_053_580, 0).saturating_mul(r.into())) + // Minimum execution time: 2_380_000 picoseconds. + Weight::from_parts(2_444_000, 0) + // Standard Error: 7_964 + .saturating_add(Weight::from_parts(1_141_337, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32rotr(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_325_000 picoseconds. - Weight::from_parts(206_699, 0) - // Standard Error: 5_851 - .saturating_add(Weight::from_parts(639_333, 0).saturating_mul(r.into())) + // Minimum execution time: 2_442_000 picoseconds. + Weight::from_parts(2_531_000, 0) + // Standard Error: 5_193 + .saturating_add(Weight::from_parts(628_586, 0).saturating_mul(r.into())) } fn tasks_remove_resume_session() -> Weight { // Proof Size summary in bytes: // Measured: `352` // Estimated: `4169` - // Minimum execution time: 6_081_000 picoseconds. - Weight::from_parts(6_314_000, 4169) + // Minimum execution time: 5_990_000 picoseconds. + Weight::from_parts(6_384_000, 4169) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) } @@ -4058,8 +4062,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `1107` // Estimated: `24053` - // Minimum execution time: 61_245_000 picoseconds. - Weight::from_parts(64_310_000, 24053) + // Minimum execution time: 64_318_000 picoseconds. + Weight::from_parts(67_713_000, 24053) .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().writes(6_u64)) } @@ -4067,8 +4071,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `888` // Estimated: `22158` - // Minimum execution time: 47_184_000 picoseconds. - Weight::from_parts(48_335_000, 22158) + // Minimum execution time: 50_396_000 picoseconds. + Weight::from_parts(57_319_000, 22158) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().writes(5_u64)) } @@ -4076,8 +4080,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `1010` // Estimated: `34619` - // Minimum execution time: 75_767_000 picoseconds. - Weight::from_parts(77_229_000, 34619) + // Minimum execution time: 81_192_000 picoseconds. + Weight::from_parts(110_464_000, 34619) .saturating_add(RocksDbWeight::get().reads(11_u64)) .saturating_add(RocksDbWeight::get().writes(10_u64)) } @@ -4085,8 +4089,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `695` // Estimated: `20509` - // Minimum execution time: 31_513_000 picoseconds. - Weight::from_parts(33_232_000, 20509) + // Minimum execution time: 33_549_000 picoseconds. + Weight::from_parts(35_457_000, 20509) .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().writes(6_u64)) } @@ -4094,8 +4098,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `976` // Estimated: `26636` - // Minimum execution time: 48_739_000 picoseconds. - Weight::from_parts(49_963_000, 26636) + // Minimum execution time: 53_062_000 picoseconds. + Weight::from_parts(55_913_000, 26636) .saturating_add(RocksDbWeight::get().reads(8_u64)) .saturating_add(RocksDbWeight::get().writes(6_u64)) } @@ -4103,16 +4107,16 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `80` // Estimated: `3545` - // Minimum execution time: 3_513_000 picoseconds. - Weight::from_parts(3_670_000, 3545) + // Minimum execution time: 3_544_000 picoseconds. + Weight::from_parts(3_797_000, 3545) .saturating_add(RocksDbWeight::get().reads(1_u64)) } fn tasks_remove_from_waitlist() -> Weight { // Proof Size summary in bytes: // Measured: `1626` // Estimated: `58232` - // Minimum execution time: 109_582_000 picoseconds. - Weight::from_parts(112_343_000, 58232) + // Minimum execution time: 119_636_000 picoseconds. + Weight::from_parts(122_812_000, 58232) .saturating_add(RocksDbWeight::get().reads(16_u64)) .saturating_add(RocksDbWeight::get().writes(13_u64)) } @@ -4120,8 +4124,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `1332` // Estimated: `46962` - // Minimum execution time: 90_789_000 picoseconds. - Weight::from_parts(93_329_000, 46962) + // Minimum execution time: 94_503_000 picoseconds. + Weight::from_parts(98_976_000, 46962) .saturating_add(RocksDbWeight::get().reads(14_u64)) .saturating_add(RocksDbWeight::get().writes(13_u64)) } @@ -4130,10 +4134,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `2303 + c * (16400 ±0)` // Estimated: `19878 + c * (84480 ±0)` - // Minimum execution time: 31_262_000 picoseconds. - Weight::from_parts(31_610_000, 19878) - // Standard Error: 69_131 - .saturating_add(Weight::from_parts(39_928_419, 0).saturating_mul(c.into())) + // Minimum execution time: 31_538_000 picoseconds. + Weight::from_parts(32_681_000, 19878) + // Standard Error: 71_008 + .saturating_add(Weight::from_parts(39_112_947, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(4_u64)) .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(c.into()))) .saturating_add(RocksDbWeight::get().writes(2_u64)) @@ -4145,10 +4149,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `3129 + c * (42 ±0)` // Estimated: `60575 + c * (2947 ±0)` - // Minimum execution time: 91_223_000 picoseconds. - Weight::from_parts(98_002_861, 60575) - // Standard Error: 2_086 - .saturating_add(Weight::from_parts(1_092_801, 0).saturating_mul(c.into())) + // Minimum execution time: 91_887_000 picoseconds. + Weight::from_parts(87_209_551, 60575) + // Standard Error: 2_248 + .saturating_add(Weight::from_parts(1_083_157, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(13_u64)) .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(c.into()))) .saturating_add(RocksDbWeight::get().writes(9_u64)) diff --git a/runtime/vara/src/weights/pallet_gear_voucher.rs b/runtime/vara/src/weights/pallet_gear_voucher.rs index 6d6889d1752..101376e2cb3 100644 --- a/runtime/vara/src/weights/pallet_gear_voucher.rs +++ b/runtime/vara/src/weights/pallet_gear_voucher.rs @@ -19,7 +19,7 @@ //! Autogenerated weights for pallet_gear_voucher //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-09-11, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-09-28, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` //! CPU: `Intel(R) Xeon(R) Platinum 8375C CPU @ 2.90GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("vara-dev"), DB CACHE: 1024 @@ -47,8 +47,8 @@ impl pallet_gear_voucher::WeightInfo for SubstrateWeigh // Proof Size summary in bytes: // Measured: `101` // Estimated: `6196` - // Minimum execution time: 25_876_000 picoseconds. - Weight::from_parts(26_659_000, 6196) + // Minimum execution time: 26_422_000 picoseconds. + Weight::from_parts(27_445_000, 6196) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) } @@ -60,8 +60,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `101` // Estimated: `6196` - // Minimum execution time: 25_876_000 picoseconds. - Weight::from_parts(26_659_000, 6196) + // Minimum execution time: 26_422_000 picoseconds. + Weight::from_parts(27_445_000, 6196) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) } diff --git a/runtime/vara/src/weights/pallet_timestamp.rs b/runtime/vara/src/weights/pallet_timestamp.rs index 5c50f24c824..37ea0ca7c11 100644 --- a/runtime/vara/src/weights/pallet_timestamp.rs +++ b/runtime/vara/src/weights/pallet_timestamp.rs @@ -19,7 +19,7 @@ //! Autogenerated weights for pallet_timestamp //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-09-11, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-09-28, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` //! CPU: `Intel(R) Xeon(R) Platinum 8375C CPU @ 2.90GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("vara-dev"), DB CACHE: 1024 @@ -48,8 +48,8 @@ impl pallet_timestamp::WeightInfo for SubstrateWeight pallet_timestamp::WeightInfo for SubstrateWeight pallet_utility::WeightInfo for SubstrateWeight // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 5_349_000 picoseconds. - Weight::from_parts(8_798_188, 0) - // Standard Error: 2_360 - .saturating_add(Weight::from_parts(3_859_914, 0).saturating_mul(c.into())) + // Minimum execution time: 5_322_000 picoseconds. + Weight::from_parts(7_918_705, 0) + // Standard Error: 2_884 + .saturating_add(Weight::from_parts(3_959_889, 0).saturating_mul(c.into())) } fn as_derivative() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 3_760_000 picoseconds. - Weight::from_parts(3_882_000, 0) + // Minimum execution time: 3_832_000 picoseconds. + Weight::from_parts(4_118_000, 0) } /// The range of component `c` is `[0, 1000]`. fn batch_all(c: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 5_343_000 picoseconds. - Weight::from_parts(6_613_150, 0) - // Standard Error: 2_902 - .saturating_add(Weight::from_parts(4_045_901, 0).saturating_mul(c.into())) + // Minimum execution time: 5_226_000 picoseconds. + Weight::from_parts(9_080_830, 0) + // Standard Error: 3_911 + .saturating_add(Weight::from_parts(4_181_646, 0).saturating_mul(c.into())) } fn dispatch_as() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 6_983_000 picoseconds. - Weight::from_parts(7_317_000, 0) + // Minimum execution time: 6_965_000 picoseconds. + Weight::from_parts(7_422_000, 0) } /// The range of component `c` is `[0, 1000]`. fn force_batch(c: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 5_419_000 picoseconds. - Weight::from_parts(9_009_348, 0) - // Standard Error: 2_400 - .saturating_add(Weight::from_parts(3_868_692, 0).saturating_mul(c.into())) + // Minimum execution time: 5_298_000 picoseconds. + Weight::from_parts(2_699_738, 0) + // Standard Error: 4_497 + .saturating_add(Weight::from_parts(4_020_014, 0).saturating_mul(c.into())) } } @@ -100,43 +100,43 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 5_349_000 picoseconds. - Weight::from_parts(8_798_188, 0) - // Standard Error: 2_360 - .saturating_add(Weight::from_parts(3_859_914, 0).saturating_mul(c.into())) + // Minimum execution time: 5_322_000 picoseconds. + Weight::from_parts(7_918_705, 0) + // Standard Error: 2_884 + .saturating_add(Weight::from_parts(3_959_889, 0).saturating_mul(c.into())) } fn as_derivative() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 3_760_000 picoseconds. - Weight::from_parts(3_882_000, 0) + // Minimum execution time: 3_832_000 picoseconds. + Weight::from_parts(4_118_000, 0) } /// The range of component `c` is `[0, 1000]`. fn batch_all(c: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 5_343_000 picoseconds. - Weight::from_parts(6_613_150, 0) - // Standard Error: 2_902 - .saturating_add(Weight::from_parts(4_045_901, 0).saturating_mul(c.into())) + // Minimum execution time: 5_226_000 picoseconds. + Weight::from_parts(9_080_830, 0) + // Standard Error: 3_911 + .saturating_add(Weight::from_parts(4_181_646, 0).saturating_mul(c.into())) } fn dispatch_as() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 6_983_000 picoseconds. - Weight::from_parts(7_317_000, 0) + // Minimum execution time: 6_965_000 picoseconds. + Weight::from_parts(7_422_000, 0) } /// The range of component `c` is `[0, 1000]`. fn force_batch(c: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 5_419_000 picoseconds. - Weight::from_parts(9_009_348, 0) - // Standard Error: 2_400 - .saturating_add(Weight::from_parts(3_868_692, 0).saturating_mul(c.into())) + // Minimum execution time: 5_298_000 picoseconds. + Weight::from_parts(2_699_738, 0) + // Standard Error: 4_497 + .saturating_add(Weight::from_parts(4_020_014, 0).saturating_mul(c.into())) } } From c7aab90c31bd2217430a23bd9c485f05a56af627 Mon Sep 17 00:00:00 2001 From: StackOverflowExcept1on <109800286+StackOverflowExcept1on@users.noreply.github.com> Date: Thu, 5 Oct 2023 11:14:06 +0300 Subject: [PATCH 5/8] feat(wasm-gen): distinguish between importing and inserting functions (#3378) --- utils/node-loader/src/utils.rs | 8 +- utils/runtime-fuzzer/src/gear_calls.rs | 8 +- utils/wasm-gen/src/config.rs | 10 +- utils/wasm-gen/src/config/syscalls.rs | 34 ++--- utils/wasm-gen/src/config/syscalls/amount.rs | 85 ------------ .../wasm-gen/src/config/syscalls/injection.rs | 128 ++++++++++++++++++ utils/wasm-gen/src/generator/syscalls.rs | 4 +- .../src/generator/syscalls/imports.rs | 88 ++++++------ utils/wasm-gen/src/tests.rs | 12 +- 9 files changed, 214 insertions(+), 163 deletions(-) delete mode 100644 utils/wasm-gen/src/config/syscalls/amount.rs create mode 100644 utils/wasm-gen/src/config/syscalls/injection.rs diff --git a/utils/node-loader/src/utils.rs b/utils/node-loader/src/utils.rs index c9f99f99e9f..821c798f218 100644 --- a/utils/node-loader/src/utils.rs +++ b/utils/node-loader/src/utils.rs @@ -8,7 +8,7 @@ use gear_core_errors::ReplyCode; use gear_utils::NonEmpty; use gear_wasm_gen::{ EntryPointsSet, InvocableSysCall, ParamType, StandardGearWasmConfigsBundle, SysCallName, - SysCallsInjectionAmounts, SysCallsParamsConfig, + SysCallsInjectionTypes, SysCallsParamsConfig, }; use gsdk::metadata::runtime_types::{ gear_common::event::DispatchStatus as GenDispatchStatus, @@ -213,8 +213,8 @@ pub fn get_wasm_gen_config( existing_programs: impl Iterator, ) -> StandardGearWasmConfigsBundle { let initial_pages = 2; - let mut injection_amounts = SysCallsInjectionAmounts::all_once(); - injection_amounts.set_multiple( + let mut injection_types = SysCallsInjectionTypes::all_once(); + injection_types.set_multiple( [ (SysCallName::Leave, 0..=0), (SysCallName::Panic, 0..=0), @@ -236,7 +236,7 @@ pub fn get_wasm_gen_config( log_info: Some(format!("Gear program seed = '{seed}'")), existing_addresses: NonEmpty::collect(existing_programs), entry_points_set: EntryPointsSet::InitHandleHandleReply, - injection_amounts, + injection_types, params_config, initial_pages: initial_pages as u32, unreachable_enabled: false, diff --git a/utils/runtime-fuzzer/src/gear_calls.rs b/utils/runtime-fuzzer/src/gear_calls.rs index 239b9e51ba6..28799831d63 100644 --- a/utils/runtime-fuzzer/src/gear_calls.rs +++ b/utils/runtime-fuzzer/src/gear_calls.rs @@ -36,7 +36,7 @@ use gear_core::ids::{CodeId, MessageId, ProgramId}; use gear_utils::NonEmpty; use gear_wasm_gen::{ EntryPointsSet, InvocableSysCall, ParamType, StandardGearWasmConfigsBundle, SysCallName, - SysCallsInjectionAmounts, SysCallsParamsConfig, + SysCallsInjectionTypes, SysCallsParamsConfig, }; /// Maximum payload size for the fuzzer - 512 KiB. @@ -405,8 +405,8 @@ fn config( log_info: Option, ) -> StandardGearWasmConfigsBundle { let initial_pages = 2; - let mut injection_amounts = SysCallsInjectionAmounts::all_once(); - injection_amounts.set_multiple( + let mut injection_types = SysCallsInjectionTypes::all_once(); + injection_types.set_multiple( [ (SysCallName::Leave, 0..=0), (SysCallName::Panic, 0..=0), @@ -438,7 +438,7 @@ fn config( StandardGearWasmConfigsBundle { entry_points_set: EntryPointsSet::InitHandleHandleReply, - injection_amounts, + injection_types, existing_addresses, log_info, params_config, diff --git a/utils/wasm-gen/src/config.rs b/utils/wasm-gen/src/config.rs index 05ff15c2a1e..a8edb35f91a 100644 --- a/utils/wasm-gen/src/config.rs +++ b/utils/wasm-gen/src/config.rs @@ -55,7 +55,7 @@ //! stack_end_page: Some(64), //! }; //! let entry_points_set = EntryPointsSet::InitHandle; -//! let sys_calls_config = SysCallsConfigBuilder::new(SysCallsInjectionAmounts::all_once()) +//! let sys_calls_config = SysCallsConfigBuilder::new(SysCallsInjectionTypes::all_once()) //! .with_source_msg_dest() //! .with_log_info("I'm from wasm-gen".into()) //! .build(); @@ -145,7 +145,7 @@ pub struct StandardGearWasmConfigsBundle { /// during wasm generation. pub call_indirect_enabled: bool, /// Injection amount ranges for each sys-call. - pub injection_amounts: SysCallsInjectionAmounts, + pub injection_types: SysCallsInjectionTypes, /// Config of gear wasm call entry-points (exports). pub entry_points_set: EntryPointsSet, /// Initial wasm memory pages. @@ -166,7 +166,7 @@ impl Default for StandardGearWasmConfigsBundle { existing_addresses: None, remove_recursion: false, call_indirect_enabled: true, - injection_amounts: SysCallsInjectionAmounts::all_once(), + injection_types: SysCallsInjectionTypes::all_once(), entry_points_set: Default::default(), initial_pages: DEFAULT_INITIAL_SIZE, stack_end_page: None, @@ -183,7 +183,7 @@ impl> ConfigsBundle for StandardGearWasmConfigsBundle { existing_addresses, remove_recursion, call_indirect_enabled, - injection_amounts, + injection_types, entry_points_set, initial_pages, stack_end_page, @@ -197,7 +197,7 @@ impl> ConfigsBundle for StandardGearWasmConfigsBundle { ..SelectableParams::default() }; - let mut sys_calls_config_builder = SysCallsConfigBuilder::new(injection_amounts); + let mut sys_calls_config_builder = SysCallsConfigBuilder::new(injection_types); if let Some(log_info) = log_info { sys_calls_config_builder = sys_calls_config_builder.with_log_info(log_info); } diff --git a/utils/wasm-gen/src/config/syscalls.rs b/utils/wasm-gen/src/config/syscalls.rs index 829cc230e94..2eab5e4dc5d 100644 --- a/utils/wasm-gen/src/config/syscalls.rs +++ b/utils/wasm-gen/src/config/syscalls.rs @@ -19,16 +19,16 @@ //! Configuration for the sys-calls imports generator, additional data injector //! and sys-calls invocations generator. -mod amount; +mod injection; mod param; mod precise; use gear_utils::NonEmpty; use gear_wasm_instrument::syscalls::SysCallName; use gsys::{Hash, HashWithValue}; -use std::{collections::HashSet, ops::RangeInclusive}; +use std::collections::HashSet; -pub use amount::*; +pub use injection::*; pub use param::*; pub use precise::*; @@ -40,9 +40,9 @@ pub struct SysCallsConfigBuilder(SysCallsConfig); impl SysCallsConfigBuilder { /// Create a new builder with defined injection amounts for all sys-calls. - pub fn new(injection_amounts: SysCallsInjectionAmounts) -> Self { + pub fn new(injection_types: SysCallsInjectionTypes) -> Self { Self(SysCallsConfig { - injection_amounts, + injection_types, params_config: SysCallsParamsConfig::default(), precise_syscalls_config: PreciseSysCallsConfig::default(), sys_call_destination: SysCallDestination::default(), @@ -71,7 +71,9 @@ impl SysCallsConfigBuilder { /// Set whether `gr_send*` and `gr_exit` sys-calls must use `gr_source` result for sys-call destination. pub fn with_source_msg_dest(mut self) -> Self { self.0.sys_call_destination = SysCallDestination::Source; - self.enable_sys_call(InvocableSysCall::Loose(SysCallName::Source)); + self.0 + .injection_types + .enable_sys_call_import(InvocableSysCall::Loose(SysCallName::Source)); self } @@ -95,7 +97,9 @@ impl SysCallsConfigBuilder { /// Choosing gear export to log data is done from best `init` to worse `handle`. pub fn with_log_info(mut self, log: String) -> Self { self.0.log_info = Some(log); - self.enable_sys_call(InvocableSysCall::Loose(SysCallName::Debug)); + self.0 + .injection_types + .enable_sys_call_import(InvocableSysCall::Loose(SysCallName::Debug)); self } @@ -107,16 +111,6 @@ impl SysCallsConfigBuilder { self } - fn enable_sys_call(&mut self, name: InvocableSysCall) { - let range = self.0.injection_amounts.get(name); - - let range_start = *range.start(); - if range_start == 0 { - let max = *range.end().max(&1); - self.0.injection_amounts.set(name, 1, max); - } - } - /// Build the [`SysCallsConfig`]. pub fn build(self) -> SysCallsConfig { self.0 @@ -150,7 +144,7 @@ impl ErrorProcessingConfig { /// United config for all entities in sys-calls generator module. #[derive(Debug, Clone, Default)] pub struct SysCallsConfig { - injection_amounts: SysCallsInjectionAmounts, + injection_types: SysCallsInjectionTypes, params_config: SysCallsParamsConfig, precise_syscalls_config: PreciseSysCallsConfig, sys_call_destination: SysCallDestination, @@ -160,8 +154,8 @@ pub struct SysCallsConfig { impl SysCallsConfig { /// Get possible number of times (range) the sys-call can be injected in the wasm. - pub fn injection_amounts(&self, name: InvocableSysCall) -> RangeInclusive { - self.injection_amounts.get(name) + pub fn injection_types(&self, name: InvocableSysCall) -> SysCallInjectionType { + self.injection_types.get(name) } /// Get defined sys-call destination for `gr_send*` and `gr_exit` sys-calls. diff --git a/utils/wasm-gen/src/config/syscalls/amount.rs b/utils/wasm-gen/src/config/syscalls/amount.rs deleted file mode 100644 index 58350dea518..00000000000 --- a/utils/wasm-gen/src/config/syscalls/amount.rs +++ /dev/null @@ -1,85 +0,0 @@ -// This file is part of Gear. - -// Copyright (C) 2021-2023 Gear Technologies Inc. -// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0 - -// This program 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. - -// This program 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 this program. If not, see . - -//! Entities describing possible amount for each sys-call to be injected into wasm module. -//! -//! Types here are used to create [`crate::SysCallsConfig`]. - -use crate::InvocableSysCall; - -use gear_wasm_instrument::syscalls::SysCallName; -use std::{collections::HashMap, ops::RangeInclusive}; - -/// Possible injection amount ranges for each sys-call. -#[derive(Debug, Clone)] -pub struct SysCallsInjectionAmounts(HashMap>); - -impl SysCallsInjectionAmounts { - /// Instantiate a sys-calls amounts ranges map, where each gear sys-call is injected into wasm-module only once. - pub fn all_once() -> Self { - Self::new_with_range(1..=1) - } - - /// Instantiate a sys-calls amounts ranges map, where no gear sys-call is ever injected into wasm-module. - pub fn all_never() -> Self { - Self::new_with_range(0..=0) - } - - /// Instantiate a sys-calls amounts ranges map with given range. - fn new_with_range(range: RangeInclusive) -> Self { - let sys_calls = SysCallName::instrumentable(); - Self( - sys_calls - .iter() - .cloned() - .map(|name| (InvocableSysCall::Loose(name), range.clone())) - .chain(sys_calls.iter().cloned().filter_map(|name| { - InvocableSysCall::has_precise_variant(name) - .then_some((InvocableSysCall::Precise(name), range.clone())) - })) - .collect(), - ) - } - - /// Get amount possible sys-call amount range. - pub fn get(&self, name: InvocableSysCall) -> RangeInclusive { - self.0 - .get(&name) - .cloned() - .expect("instantiated with all sys-calls set") - } - - /// Sets possible amount range for the the sys-call. - pub fn set(&mut self, name: InvocableSysCall, min: u32, max: u32) { - self.0.insert(name, min..=max); - } - - /// Same as [`SysCallsAmountRanges::set`], but sets amount ranges for multiple sys-calls. - pub fn set_multiple( - &mut self, - sys_calls_freqs: impl Iterator)>, - ) { - self.0.extend(sys_calls_freqs) - } -} - -impl Default for SysCallsInjectionAmounts { - fn default() -> Self { - Self::all_once() - } -} diff --git a/utils/wasm-gen/src/config/syscalls/injection.rs b/utils/wasm-gen/src/config/syscalls/injection.rs new file mode 100644 index 00000000000..c466f552810 --- /dev/null +++ b/utils/wasm-gen/src/config/syscalls/injection.rs @@ -0,0 +1,128 @@ +// This file is part of Gear. + +// Copyright (C) 2021-2023 Gear Technologies Inc. +// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0 + +// This program 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. + +// This program 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 this program. If not, see . + +//! Entities describing possible injection types for each sys-call. +//! These entities allows to configure which sys-calls to insert into +//! code section of wasm module and which ones to simply import. +//! +//! Types here are used to create [`crate::SysCallsConfig`]. + +use crate::InvocableSysCall; + +use gear_wasm_instrument::syscalls::SysCallName; +use std::{collections::HashMap, ops::RangeInclusive}; + +/// This enum defines how the sys-call should be injected into wasm module. +#[derive(Debug, Clone)] +pub enum SysCallInjectionType { + /// Don't modify wasm module at all. + None, + /// Sys-call import will be injected into import section of wasm module, + /// but the `wasm-gen` generators will not call that sys-call. + /// + /// It should be used in cases where you don't need to invoke an actual sys-call. + /// For example, `precision_gr_reservation_send` sys-call uses `gr_reserve_gas` under + /// the hood. In this case, `gr_reserve_gas` will be imported but will not be called. + Import, + /// Sys-call import will be injected into import section of wasm module, + /// and the `wasm-gen` generators will insert invoke instructions for that sys-call. + /// + /// It also has `sys_call_amount_range: RangeInclusive` - the range from which + /// amount of sys-calls will be generated for injection into code section of wasm module. + Function(RangeInclusive), +} + +/// Possible injection types for each sys-call. +#[derive(Debug, Clone)] +pub struct SysCallsInjectionTypes(HashMap); + +impl SysCallsInjectionTypes { + /// Instantiate a sys-calls map, where each gear sys-call is injected into wasm-module only once. + pub fn all_once() -> Self { + Self::new_with_injection_type(SysCallInjectionType::Function(1..=1)) + } + + /// Instantiate a sys-calls map, where no gear sys-call is ever injected into wasm-module. + pub fn all_never() -> Self { + Self::new_with_injection_type(SysCallInjectionType::None) + } + + /// Instantiate a sys-calls map with given injection type. + fn new_with_injection_type(injection_type: SysCallInjectionType) -> Self { + let sys_calls = SysCallName::instrumentable(); + Self( + sys_calls + .iter() + .cloned() + .map(|name| (InvocableSysCall::Loose(name), injection_type.clone())) + .chain(sys_calls.iter().cloned().filter_map(|name| { + InvocableSysCall::has_precise_variant(name) + .then_some((InvocableSysCall::Precise(name), injection_type.clone())) + })) + .collect(), + ) + } + + /// Gets injection type for given sys-call. + pub fn get(&self, name: InvocableSysCall) -> SysCallInjectionType { + self.0 + .get(&name) + .cloned() + .expect("instantiated with all sys-calls set") + } + + /// Sets possible amount range for the the sys-call. + pub fn set(&mut self, name: InvocableSysCall, min: u32, max: u32) { + self.0 + .insert(name, SysCallInjectionType::Function(min..=max)); + + if let InvocableSysCall::Precise(sys_call) = name { + let Some(required_imports) = InvocableSysCall::required_imports_for_sys_call(sys_call) else { + return; + }; + + for &sys_call_import in required_imports { + self.enable_sys_call_import(InvocableSysCall::Loose(sys_call_import)); + } + } + } + + /// Imports the given sys-call if necessary. + pub(crate) fn enable_sys_call_import(&mut self, name: InvocableSysCall) { + if let Some(injection_type @ SysCallInjectionType::None) = self.0.get_mut(&name) { + *injection_type = SysCallInjectionType::Import; + } + } + + /// Same as [`SysCallsInjectionTypes::set`], but sets amount ranges for multiple sys-calls. + pub fn set_multiple( + &mut self, + sys_calls_freqs: impl Iterator)>, + ) { + for (name, range) in sys_calls_freqs { + let (min, max) = range.into_inner(); + self.set(name, min, max); + } + } +} + +impl Default for SysCallsInjectionTypes { + fn default() -> Self { + Self::all_once() + } +} diff --git a/utils/wasm-gen/src/generator/syscalls.rs b/utils/wasm-gen/src/generator/syscalls.rs index e85c5bba222..8e2d34b857d 100644 --- a/utils/wasm-gen/src/generator/syscalls.rs +++ b/utils/wasm-gen/src/generator/syscalls.rs @@ -149,7 +149,9 @@ impl InvocableSysCall { } /// Returns the required imports to build precise sys-call. - fn required_imports_for_sys_call(sys_call: SysCallName) -> Option<&'static [SysCallName]> { + pub(crate) fn required_imports_for_sys_call( + sys_call: SysCallName, + ) -> Option<&'static [SysCallName]> { // NOTE: the last sys-call must be pattern itself Some(match sys_call { SysCallName::ReservationSend => { diff --git a/utils/wasm-gen/src/generator/syscalls/imports.rs b/utils/wasm-gen/src/generator/syscalls/imports.rs index 797bbc6e685..121151e0532 100644 --- a/utils/wasm-gen/src/generator/syscalls/imports.rs +++ b/utils/wasm-gen/src/generator/syscalls/imports.rs @@ -24,7 +24,7 @@ use crate::{ GearWasmGenerator, MemoryImportGenerationProof, ModuleWithCallIndexes, }, wasm::{PageCount as WasmPageCount, WasmModule}, - InvocableSysCall, SysCallsConfig, + InvocableSysCall, SysCallInjectionType, SysCallsConfig, }; use arbitrary::{Error as ArbitraryError, Result, Unstructured}; use gear_wasm_instrument::{ @@ -57,9 +57,16 @@ pub struct SysCallsImportsGeneratorInstantiator<'a, 'b>( ), ); +/// The set of sys-calls that need to be imported to create precise sys-call. +#[derive(thiserror::Error, Debug)] +#[error("The following sys-calls must be imported: {0:?}")] +pub struct RequiredSysCalls(&'static [SysCallName]); + /// An error that occurs when generating precise sys-call. #[derive(thiserror::Error, Debug)] pub enum PreciseSysCallError { + #[error("{0}")] + RequiredImports(#[from] RequiredSysCalls), #[error("{0}")] Arbitrary(#[from] ArbitraryError), } @@ -204,18 +211,23 @@ impl<'a, 'b> SysCallsImportsGenerator<'a, 'b> { ]; for (sys_call, generate_method) in sys_calls { - let sys_call_amount_range = self + let sys_call_injection_type = self .config - .injection_amounts(InvocableSysCall::Precise(sys_call)); - let sys_call_amount = self.unstructured.int_in_range(sys_call_amount_range)?; - for _ in 0..sys_call_amount { - log::trace!( - "Constructing {name} sys-call...", - name = InvocableSysCall::Precise(sys_call).to_str() - ); - - if let Err(PreciseSysCallError::Arbitrary(err)) = generate_method(self, sys_call) { - return Err(err); + .injection_types(InvocableSysCall::Precise(sys_call)); + if let SysCallInjectionType::Function(sys_call_amount_range) = sys_call_injection_type { + let sys_call_amount = self.unstructured.int_in_range(sys_call_amount_range)?; + for _ in 0..sys_call_amount { + log::trace!( + "Constructing {name} sys-call...", + name = InvocableSysCall::Precise(sys_call).to_str() + ); + + if let Err(err) = generate_method(self, sys_call) { + match err { + PreciseSysCallError::RequiredImports(err) => log::trace!("{err}"), + PreciseSysCallError::Arbitrary(err) => return Err(err), + } + } } } } @@ -232,20 +244,26 @@ impl<'a, 'b> SysCallsImportsGenerator<'a, 'b> { &mut self, sys_call: SysCallName, ) -> Result> { - let sys_call_amount_range = self + let sys_call_injection_type = self .config - .injection_amounts(InvocableSysCall::Loose(sys_call)); - let sys_call_amount = self.unstructured.int_in_range(sys_call_amount_range)?; - Ok((sys_call_amount != 0).then(|| { - let call_indexes_handle = self.insert_sys_call_import(sys_call); - log::trace!( - " -- Generated {} amount of {} sys-call", - sys_call_amount, - sys_call.to_str() - ); + .injection_types(InvocableSysCall::Loose(sys_call)); - (sys_call_amount, call_indexes_handle) - })) + let sys_call_amount = match sys_call_injection_type { + SysCallInjectionType::Import => 0, + SysCallInjectionType::Function(sys_call_amount_range) => { + self.unstructured.int_in_range(sys_call_amount_range)? + } + _ => return Ok(None), + }; + + let call_indexes_handle = self.insert_sys_call_import(sys_call); + log::trace!( + " -- Generated {} amount of {} sys-call", + sys_call_amount, + sys_call.to_str() + ); + + Ok(Some((sys_call_amount, call_indexes_handle))) } /// Inserts gear sys-call defined by the `sys_call` param. @@ -291,9 +309,9 @@ impl<'a, 'b> SysCallsImportsGenerator<'a, 'b> { /// Returns the indexes of invocable sys-calls. fn invocable_sys_calls_indexes( - &mut self, + &self, sys_calls: &'static [SysCallName; N], - ) -> [usize; N] { + ) -> Result<[usize; N], RequiredSysCalls> { let mut indexes = [0; N]; for (index, &sys_call) in indexes.iter_mut().zip(sys_calls.iter()) { @@ -301,16 +319,10 @@ impl<'a, 'b> SysCallsImportsGenerator<'a, 'b> { .sys_calls_imports .get(&InvocableSysCall::Loose(sys_call)) .map(|&(_, call_indexes_handle)| call_indexes_handle) - .unwrap_or_else(|| { - // insert required import when we can't find it - let call_indexes_handle = self.insert_sys_call_import(sys_call); - self.sys_calls_imports - .insert(InvocableSysCall::Loose(sys_call), (0, call_indexes_handle)); - call_indexes_handle - }) + .ok_or_else(|| RequiredSysCalls(&sys_calls[..]))?; } - indexes + Ok(indexes) } /// Generates a function which calls "properly" the given sys-call. @@ -376,7 +388,7 @@ impl<'a, 'b> SysCallsImportsGenerator<'a, 'b> { sys_call: SysCallName, ) -> Result<(), PreciseSysCallError> { let [reserve_gas_idx, reservation_send_idx] = - self.invocable_sys_calls_indexes(InvocableSysCall::required_imports(sys_call)); + self.invocable_sys_calls_indexes(InvocableSysCall::required_imports(sys_call))?; // subtract to be sure we are in memory boundaries. let rid_pid_value_ptr = self.reserve_memory(); @@ -467,7 +479,7 @@ impl<'a, 'b> SysCallsImportsGenerator<'a, 'b> { sys_call: SysCallName, ) -> Result<(), PreciseSysCallError> { let [reserve_gas_idx, reservation_reply_idx] = - self.invocable_sys_calls_indexes(InvocableSysCall::required_imports(sys_call)); + self.invocable_sys_calls_indexes(InvocableSysCall::required_imports(sys_call))?; // subtract to be sure we are in memory boundaries. let rid_value_ptr = self.reserve_memory(); @@ -536,7 +548,7 @@ impl<'a, 'b> SysCallsImportsGenerator<'a, 'b> { /// Generates a function which calls "properly" the `gr_send_commit`. fn generate_send_commit(&mut self, sys_call: SysCallName) -> Result<(), PreciseSysCallError> { let [send_init_idx, send_push_idx, send_commit_idx] = - self.invocable_sys_calls_indexes(InvocableSysCall::required_imports(sys_call)); + self.invocable_sys_calls_indexes(InvocableSysCall::required_imports(sys_call))?; // subtract to be sure we are in memory boundaries. let handle_ptr = self.reserve_memory(); @@ -636,7 +648,7 @@ impl<'a, 'b> SysCallsImportsGenerator<'a, 'b> { sys_call: SysCallName, ) -> Result<(), PreciseSysCallError> { let [size_idx, send_init_idx, send_push_input_idx, send_commit_wgas_idx] = - self.invocable_sys_calls_indexes(InvocableSysCall::required_imports(sys_call)); + self.invocable_sys_calls_indexes(InvocableSysCall::required_imports(sys_call))?; // subtract to be sure we are in memory boundaries. let handle_ptr = self.reserve_memory(); diff --git a/utils/wasm-gen/src/tests.rs b/utils/wasm-gen/src/tests.rs index fa5887bbe6a..00860fb1677 100644 --- a/utils/wasm-gen/src/tests.rs +++ b/utils/wasm-gen/src/tests.rs @@ -198,11 +198,11 @@ fn error_processing_works_for_fallible_syscalls() { const INJECTED_SYSCALLS: u32 = 8; - let mut injection_amounts = SysCallsInjectionAmounts::all_never(); - injection_amounts.set(syscall, INJECTED_SYSCALLS, INJECTED_SYSCALLS); + let mut injection_types = SysCallsInjectionTypes::all_never(); + injection_types.set(syscall, INJECTED_SYSCALLS, INJECTED_SYSCALLS); let sys_calls_config_builder = - SysCallsConfigBuilder::new(injection_amounts).with_params_config(params_config); + SysCallsConfigBuilder::new(injection_types).with_params_config(params_config); // Assert that syscalls results will be processed. let termination_reason = execute_wasm_with_custom_configs( @@ -264,8 +264,8 @@ fn precise_syscalls_works() { // Prepare sys-calls config & context settings for test case. const INJECTED_SYSCALLS: u32 = 1; - let mut injection_amounts = SysCallsInjectionAmounts::all_never(); - injection_amounts.set(syscall, INJECTED_SYSCALLS, INJECTED_SYSCALLS); + let mut injection_types = SysCallsInjectionTypes::all_never(); + injection_types.set(syscall, INJECTED_SYSCALLS, INJECTED_SYSCALLS); let mut param_config = SysCallsParamsConfig::default(); param_config.add_rule(ParamType::Gas, (0..=0).into()); @@ -273,7 +273,7 @@ fn precise_syscalls_works() { // Assert that syscalls results will be processed. let termination_reason = execute_wasm_with_custom_configs( &mut unstructured, - SysCallsConfigBuilder::new(injection_amounts) + SysCallsConfigBuilder::new(injection_types) .with_params_config(param_config) .with_precise_syscalls_config(PreciseSysCallsConfig::new(3..=3)) .with_source_msg_dest() From ae31dbb201e4ffa0a098efd312524ba4476ca563 Mon Sep 17 00:00:00 2001 From: Vadim Smirnov Date: Thu, 5 Oct 2023 13:53:09 +0400 Subject: [PATCH 6/8] feat(vara): Add nomination_pools and staking runtime-api (#3388) --- Cargo.lock | 314 +++++++++++++++++++++------------------- Cargo.toml | 1 + runtime/vara/Cargo.toml | 2 + runtime/vara/src/lib.rs | 36 ++++- 4 files changed, 195 insertions(+), 158 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 7f0a3f8fa43..076ee790ae9 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3156,7 +3156,7 @@ checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1" [[package]] name = "fork-tree" version = "3.0.0" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "parity-scale-codec", ] @@ -3179,7 +3179,7 @@ checksum = "6c2141d6d6c8512188a7891b4b01590a45f6dac67afb4f255c4124dbb86d4eaa" [[package]] name = "frame-benchmarking" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "frame-support", "frame-support-procedural", @@ -3204,7 +3204,7 @@ dependencies = [ [[package]] name = "frame-benchmarking-cli" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "Inflector", "array-bytes", @@ -3251,7 +3251,7 @@ dependencies = [ [[package]] name = "frame-election-provider-solution-type" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "proc-macro-crate 1.1.3", "proc-macro2", @@ -3262,7 +3262,7 @@ dependencies = [ [[package]] name = "frame-election-provider-support" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "frame-election-provider-solution-type", "frame-support", @@ -3279,7 +3279,7 @@ dependencies = [ [[package]] name = "frame-executive" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "frame-support", "frame-system", @@ -3308,7 +3308,7 @@ dependencies = [ [[package]] name = "frame-remote-externalities" version = "0.10.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "futures", "log", @@ -3324,7 +3324,7 @@ dependencies = [ [[package]] name = "frame-support" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "bitflags 1.3.2", "environmental", @@ -3357,7 +3357,7 @@ dependencies = [ [[package]] name = "frame-support-procedural" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "Inflector", "cfg-expr", @@ -3372,7 +3372,7 @@ dependencies = [ [[package]] name = "frame-support-procedural-tools" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "frame-support-procedural-tools-derive", "proc-macro-crate 1.1.3", @@ -3384,7 +3384,7 @@ dependencies = [ [[package]] name = "frame-support-procedural-tools-derive" version = "3.0.0" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "proc-macro2", "quote", @@ -3394,7 +3394,7 @@ dependencies = [ [[package]] name = "frame-support-test" version = "3.0.0" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "frame-benchmarking", "frame-support", @@ -3418,7 +3418,7 @@ dependencies = [ [[package]] name = "frame-support-test-pallet" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "frame-support", "frame-system", @@ -3429,7 +3429,7 @@ dependencies = [ [[package]] name = "frame-system" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "frame-support", "log", @@ -3447,7 +3447,7 @@ dependencies = [ [[package]] name = "frame-system-benchmarking" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "frame-benchmarking", "frame-support", @@ -3462,7 +3462,7 @@ dependencies = [ [[package]] name = "frame-system-rpc-runtime-api" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "parity-scale-codec", "sp-api", @@ -3471,7 +3471,7 @@ dependencies = [ [[package]] name = "frame-try-runtime" version = "0.10.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "frame-support", "parity-scale-codec", @@ -4502,7 +4502,7 @@ dependencies = [ [[package]] name = "generate-bags" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "chrono", "frame-election-provider-support", @@ -7167,7 +7167,7 @@ dependencies = [ [[package]] name = "pallet-authority-discovery" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "frame-support", "frame-system", @@ -7183,7 +7183,7 @@ dependencies = [ [[package]] name = "pallet-authorship" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "frame-support", "frame-system", @@ -7197,7 +7197,7 @@ dependencies = [ [[package]] name = "pallet-babe" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "frame-benchmarking", "frame-support", @@ -7221,7 +7221,7 @@ dependencies = [ [[package]] name = "pallet-bags-list" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "frame-benchmarking", "frame-election-provider-support", @@ -7241,7 +7241,7 @@ dependencies = [ [[package]] name = "pallet-balances" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "frame-benchmarking", "frame-support", @@ -7256,7 +7256,7 @@ dependencies = [ [[package]] name = "pallet-bounties" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "frame-benchmarking", "frame-support", @@ -7274,7 +7274,7 @@ dependencies = [ [[package]] name = "pallet-child-bounties" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "frame-benchmarking", "frame-support", @@ -7293,7 +7293,7 @@ dependencies = [ [[package]] name = "pallet-conviction-voting" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "assert_matches", "frame-benchmarking", @@ -7310,7 +7310,7 @@ dependencies = [ [[package]] name = "pallet-election-provider-multi-phase" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "frame-benchmarking", "frame-election-provider-support", @@ -7333,7 +7333,7 @@ dependencies = [ [[package]] name = "pallet-election-provider-support-benchmarking" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "frame-benchmarking", "frame-election-provider-support", @@ -7752,7 +7752,7 @@ dependencies = [ [[package]] name = "pallet-grandpa" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "frame-benchmarking", "frame-support", @@ -7775,7 +7775,7 @@ dependencies = [ [[package]] name = "pallet-identity" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "enumflags2 0.7.7", "frame-benchmarking", @@ -7791,7 +7791,7 @@ dependencies = [ [[package]] name = "pallet-im-online" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "frame-benchmarking", "frame-support", @@ -7811,7 +7811,7 @@ dependencies = [ [[package]] name = "pallet-multisig" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "frame-benchmarking", "frame-support", @@ -7827,7 +7827,7 @@ dependencies = [ [[package]] name = "pallet-nomination-pools" version = "1.0.0" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "frame-support", "frame-system", @@ -7844,7 +7844,7 @@ dependencies = [ [[package]] name = "pallet-nomination-pools-runtime-api" version = "1.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "pallet-nomination-pools", "parity-scale-codec", @@ -7855,7 +7855,7 @@ dependencies = [ [[package]] name = "pallet-offences" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "frame-support", "frame-system", @@ -7872,7 +7872,7 @@ dependencies = [ [[package]] name = "pallet-preimage" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "frame-benchmarking", "frame-support", @@ -7889,7 +7889,7 @@ dependencies = [ [[package]] name = "pallet-proxy" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "frame-benchmarking", "frame-support", @@ -7904,7 +7904,7 @@ dependencies = [ [[package]] name = "pallet-ranked-collective" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "frame-benchmarking", "frame-support", @@ -7922,7 +7922,7 @@ dependencies = [ [[package]] name = "pallet-referenda" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "assert_matches", "frame-benchmarking", @@ -7941,7 +7941,7 @@ dependencies = [ [[package]] name = "pallet-scheduler" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "frame-benchmarking", "frame-support", @@ -7958,7 +7958,7 @@ dependencies = [ [[package]] name = "pallet-session" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "frame-support", "frame-system", @@ -7979,7 +7979,7 @@ dependencies = [ [[package]] name = "pallet-staking" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "frame-benchmarking", "frame-election-provider-support", @@ -8002,16 +8002,25 @@ dependencies = [ [[package]] name = "pallet-staking-reward-fn" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "log", "sp-arithmetic 6.0.0 (git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox)", ] +[[package]] +name = "pallet-staking-runtime-api" +version = "4.0.0-dev" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" +dependencies = [ + "parity-scale-codec", + "sp-api", +] + [[package]] name = "pallet-sudo" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "frame-support", "frame-system", @@ -8025,7 +8034,7 @@ dependencies = [ [[package]] name = "pallet-timestamp" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "frame-benchmarking", "frame-support", @@ -8043,7 +8052,7 @@ dependencies = [ [[package]] name = "pallet-transaction-payment" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "frame-support", "frame-system", @@ -8059,7 +8068,7 @@ dependencies = [ [[package]] name = "pallet-transaction-payment-rpc" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "jsonrpsee", "pallet-transaction-payment-rpc-runtime-api", @@ -8075,7 +8084,7 @@ dependencies = [ [[package]] name = "pallet-transaction-payment-rpc-runtime-api" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "pallet-transaction-payment", "parity-scale-codec", @@ -8087,7 +8096,7 @@ dependencies = [ [[package]] name = "pallet-treasury" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "frame-benchmarking", "frame-support", @@ -8104,7 +8113,7 @@ dependencies = [ [[package]] name = "pallet-utility" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "frame-benchmarking", "frame-support", @@ -8120,7 +8129,7 @@ dependencies = [ [[package]] name = "pallet-vesting" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "frame-benchmarking", "frame-support", @@ -8135,7 +8144,7 @@ dependencies = [ [[package]] name = "pallet-whitelist" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "frame-benchmarking", "frame-support", @@ -9622,7 +9631,7 @@ dependencies = [ [[package]] name = "sc-authority-discovery" version = "0.10.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "async-trait", "futures", @@ -9650,7 +9659,7 @@ dependencies = [ [[package]] name = "sc-block-builder" version = "0.10.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "parity-scale-codec", "sc-client-api", @@ -9665,7 +9674,7 @@ dependencies = [ [[package]] name = "sc-chain-spec" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "memmap2", "sc-chain-spec-derive", @@ -9684,7 +9693,7 @@ dependencies = [ [[package]] name = "sc-chain-spec-derive" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "proc-macro-crate 1.1.3", "proc-macro2", @@ -9695,7 +9704,7 @@ dependencies = [ [[package]] name = "sc-cli" version = "0.10.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "array-bytes", "chrono", @@ -9735,7 +9744,7 @@ dependencies = [ [[package]] name = "sc-client-api" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "fnv", "futures", @@ -9761,7 +9770,7 @@ dependencies = [ [[package]] name = "sc-client-db" version = "0.10.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "hash-db", "kvdb", @@ -9787,7 +9796,7 @@ dependencies = [ [[package]] name = "sc-consensus" version = "0.10.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "async-trait", "futures", @@ -9812,7 +9821,7 @@ dependencies = [ [[package]] name = "sc-consensus-babe" version = "0.10.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "async-trait", "fork-tree", @@ -9851,7 +9860,7 @@ dependencies = [ [[package]] name = "sc-consensus-babe-rpc" version = "0.10.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "futures", "jsonrpsee", @@ -9873,7 +9882,7 @@ dependencies = [ [[package]] name = "sc-consensus-epochs" version = "0.10.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "fork-tree", "parity-scale-codec", @@ -9886,7 +9895,7 @@ dependencies = [ [[package]] name = "sc-consensus-grandpa" version = "0.10.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "ahash 0.8.3", "array-bytes", @@ -9926,7 +9935,7 @@ dependencies = [ [[package]] name = "sc-consensus-grandpa-rpc" version = "0.10.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "finality-grandpa", "futures", @@ -9946,7 +9955,7 @@ dependencies = [ [[package]] name = "sc-consensus-slots" version = "0.10.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "async-trait", "futures", @@ -9969,7 +9978,7 @@ dependencies = [ [[package]] name = "sc-executor" version = "0.10.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "lru", "parity-scale-codec", @@ -9993,7 +10002,7 @@ dependencies = [ [[package]] name = "sc-executor-common" version = "0.10.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "sp-allocator", "sp-maybe-compressed-blob", @@ -10006,7 +10015,7 @@ dependencies = [ [[package]] name = "sc-executor-wasmi" version = "0.10.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "log", "sc-executor-common", @@ -10019,7 +10028,7 @@ dependencies = [ [[package]] name = "sc-executor-wasmtime" version = "0.10.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "anyhow", "cfg-if", @@ -10037,7 +10046,7 @@ dependencies = [ [[package]] name = "sc-informant" version = "0.10.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "ansi_term", "futures", @@ -10053,7 +10062,7 @@ dependencies = [ [[package]] name = "sc-keystore" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "array-bytes", "async-trait", @@ -10068,7 +10077,7 @@ dependencies = [ [[package]] name = "sc-network" version = "0.10.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "array-bytes", "async-channel", @@ -10112,7 +10121,7 @@ dependencies = [ [[package]] name = "sc-network-bitswap" version = "0.10.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "cid", "futures", @@ -10132,7 +10141,7 @@ dependencies = [ [[package]] name = "sc-network-common" version = "0.10.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "array-bytes", "async-trait", @@ -10160,7 +10169,7 @@ dependencies = [ [[package]] name = "sc-network-gossip" version = "0.10.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "ahash 0.8.3", "futures", @@ -10179,7 +10188,7 @@ dependencies = [ [[package]] name = "sc-network-light" version = "0.10.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "array-bytes", "futures", @@ -10201,7 +10210,7 @@ dependencies = [ [[package]] name = "sc-network-sync" version = "0.10.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "array-bytes", "async-trait", @@ -10235,7 +10244,7 @@ dependencies = [ [[package]] name = "sc-network-transactions" version = "0.10.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "array-bytes", "futures", @@ -10255,7 +10264,7 @@ dependencies = [ [[package]] name = "sc-offchain" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "array-bytes", "bytes", @@ -10286,7 +10295,7 @@ dependencies = [ [[package]] name = "sc-peerset" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "futures", "libp2p", @@ -10299,7 +10308,7 @@ dependencies = [ [[package]] name = "sc-proposer-metrics" version = "0.10.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "log", "substrate-prometheus-endpoint", @@ -10308,7 +10317,7 @@ dependencies = [ [[package]] name = "sc-rpc" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "futures", "jsonrpsee", @@ -10338,7 +10347,7 @@ dependencies = [ [[package]] name = "sc-rpc-api" version = "0.10.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "jsonrpsee", "parity-scale-codec", @@ -10357,7 +10366,7 @@ dependencies = [ [[package]] name = "sc-rpc-server" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "http", "jsonrpsee", @@ -10372,7 +10381,7 @@ dependencies = [ [[package]] name = "sc-rpc-spec-v2" version = "0.10.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "array-bytes", "futures", @@ -10398,7 +10407,7 @@ dependencies = [ [[package]] name = "sc-service" version = "0.10.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "async-trait", "directories 4.0.1", @@ -10464,7 +10473,7 @@ dependencies = [ [[package]] name = "sc-state-db" version = "0.10.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "log", "parity-scale-codec", @@ -10475,7 +10484,7 @@ dependencies = [ [[package]] name = "sc-storage-monitor" version = "0.1.0" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "clap 4.4.2", "fs4", @@ -10491,7 +10500,7 @@ dependencies = [ [[package]] name = "sc-sync-state-rpc" version = "0.10.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "jsonrpsee", "parity-scale-codec", @@ -10510,7 +10519,7 @@ dependencies = [ [[package]] name = "sc-sysinfo" version = "6.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "futures", "libc", @@ -10529,7 +10538,7 @@ dependencies = [ [[package]] name = "sc-telemetry" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "chrono", "futures", @@ -10548,7 +10557,7 @@ dependencies = [ [[package]] name = "sc-tracing" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "ansi_term", "atty", @@ -10579,7 +10588,7 @@ dependencies = [ [[package]] name = "sc-tracing-proc-macro" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "proc-macro-crate 1.1.3", "proc-macro2", @@ -10590,7 +10599,7 @@ dependencies = [ [[package]] name = "sc-transaction-pool" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "async-trait", "futures", @@ -10617,7 +10626,7 @@ dependencies = [ [[package]] name = "sc-transaction-pool-api" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "async-trait", "futures", @@ -10631,7 +10640,7 @@ dependencies = [ [[package]] name = "sc-utils" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "async-channel", "futures", @@ -11273,7 +11282,7 @@ dependencies = [ [[package]] name = "sp-allocator" version = "4.1.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "log", "parity-scale-codec", @@ -11284,7 +11293,7 @@ dependencies = [ [[package]] name = "sp-api" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "hash-db", "log", @@ -11302,7 +11311,7 @@ dependencies = [ [[package]] name = "sp-api-proc-macro" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "Inflector", "blake2", @@ -11329,7 +11338,7 @@ dependencies = [ [[package]] name = "sp-application-crypto" version = "7.0.0" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "parity-scale-codec", "scale-info", @@ -11356,7 +11365,7 @@ dependencies = [ [[package]] name = "sp-arithmetic" version = "6.0.0" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "integer-sqrt", "num-traits", @@ -11370,7 +11379,7 @@ dependencies = [ [[package]] name = "sp-authority-discovery" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "parity-scale-codec", "scale-info", @@ -11383,7 +11392,7 @@ dependencies = [ [[package]] name = "sp-block-builder" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "parity-scale-codec", "sp-api", @@ -11395,7 +11404,7 @@ dependencies = [ [[package]] name = "sp-blockchain" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "futures", "log", @@ -11413,7 +11422,7 @@ dependencies = [ [[package]] name = "sp-consensus" version = "0.10.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "async-trait", "futures", @@ -11428,7 +11437,7 @@ dependencies = [ [[package]] name = "sp-consensus-aura" version = "0.10.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "async-trait", "parity-scale-codec", @@ -11446,7 +11455,7 @@ dependencies = [ [[package]] name = "sp-consensus-babe" version = "0.10.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "async-trait", "merlin", @@ -11469,7 +11478,7 @@ dependencies = [ [[package]] name = "sp-consensus-grandpa" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "finality-grandpa", "log", @@ -11487,7 +11496,7 @@ dependencies = [ [[package]] name = "sp-consensus-slots" version = "0.10.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "parity-scale-codec", "scale-info", @@ -11499,7 +11508,7 @@ dependencies = [ [[package]] name = "sp-consensus-vrf" version = "0.10.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "parity-scale-codec", "scale-info", @@ -11555,7 +11564,7 @@ dependencies = [ [[package]] name = "sp-core" version = "7.0.0" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "array-bytes", "base58", @@ -11613,7 +11622,7 @@ dependencies = [ [[package]] name = "sp-core-hashing" version = "5.0.0" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "blake2b_simd", "byteorder", @@ -11627,7 +11636,7 @@ dependencies = [ [[package]] name = "sp-core-hashing-proc-macro" version = "5.0.0" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "proc-macro2", "quote", @@ -11638,7 +11647,7 @@ dependencies = [ [[package]] name = "sp-database" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "kvdb", "parking_lot 0.12.1", @@ -11657,7 +11666,7 @@ dependencies = [ [[package]] name = "sp-debug-derive" version = "5.0.0" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "proc-macro2", "quote", @@ -11678,7 +11687,7 @@ dependencies = [ [[package]] name = "sp-externalities" version = "0.13.0" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "environmental", "parity-scale-codec", @@ -11689,7 +11698,7 @@ dependencies = [ [[package]] name = "sp-inherents" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "async-trait", "impl-trait-for-tuples", @@ -11730,7 +11739,7 @@ dependencies = [ [[package]] name = "sp-io" version = "7.0.0" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "bytes", "ed25519 1.5.3", @@ -11755,7 +11764,7 @@ dependencies = [ [[package]] name = "sp-keyring" version = "7.0.0" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "lazy_static", "sp-core 7.0.0 (git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox)", @@ -11782,7 +11791,7 @@ dependencies = [ [[package]] name = "sp-keystore" version = "0.13.0" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "async-trait", "futures", @@ -11799,7 +11808,7 @@ dependencies = [ [[package]] name = "sp-maybe-compressed-blob" version = "4.1.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "thiserror", "zstd", @@ -11808,7 +11817,7 @@ dependencies = [ [[package]] name = "sp-npos-elections" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "parity-scale-codec", "scale-info", @@ -11822,7 +11831,7 @@ dependencies = [ [[package]] name = "sp-offchain" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "sp-api", "sp-core 7.0.0 (git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox)", @@ -11842,7 +11851,7 @@ dependencies = [ [[package]] name = "sp-panic-handler" version = "5.0.0" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "backtrace", "lazy_static", @@ -11852,7 +11861,7 @@ dependencies = [ [[package]] name = "sp-rpc" version = "6.0.0" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "rustc-hash", "serde", @@ -11884,7 +11893,7 @@ dependencies = [ [[package]] name = "sp-runtime" version = "7.0.0" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "either", "hash256-std-hasher", @@ -11924,7 +11933,7 @@ dependencies = [ [[package]] name = "sp-runtime-interface" version = "7.0.0" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "bytes", "impl-trait-for-tuples", @@ -11954,7 +11963,7 @@ dependencies = [ [[package]] name = "sp-runtime-interface-proc-macro" version = "6.0.0" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "Inflector", "proc-macro-crate 1.1.3", @@ -11966,7 +11975,7 @@ dependencies = [ [[package]] name = "sp-session" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "parity-scale-codec", "scale-info", @@ -11980,7 +11989,7 @@ dependencies = [ [[package]] name = "sp-staking" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "parity-scale-codec", "scale-info", @@ -12012,7 +12021,7 @@ dependencies = [ [[package]] name = "sp-state-machine" version = "0.13.0" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "hash-db", "log", @@ -12037,7 +12046,7 @@ source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0 [[package]] name = "sp-std" version = "5.0.0" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" [[package]] name = "sp-storage" @@ -12055,7 +12064,7 @@ dependencies = [ [[package]] name = "sp-storage" version = "7.0.0" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "impl-serde", "parity-scale-codec", @@ -12068,7 +12077,7 @@ dependencies = [ [[package]] name = "sp-timestamp" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "async-trait", "futures-timer", @@ -12095,7 +12104,7 @@ dependencies = [ [[package]] name = "sp-tracing" version = "6.0.0" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "parity-scale-codec", "sp-std 5.0.0 (git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox)", @@ -12107,7 +12116,7 @@ dependencies = [ [[package]] name = "sp-transaction-pool" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "sp-api", "sp-runtime 7.0.0 (git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox)", @@ -12116,7 +12125,7 @@ dependencies = [ [[package]] name = "sp-transaction-storage-proof" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "async-trait", "log", @@ -12155,7 +12164,7 @@ dependencies = [ [[package]] name = "sp-trie" version = "7.0.0" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "ahash 0.8.3", "hash-db", @@ -12178,7 +12187,7 @@ dependencies = [ [[package]] name = "sp-version" version = "5.0.0" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "impl-serde", "parity-scale-codec", @@ -12195,7 +12204,7 @@ dependencies = [ [[package]] name = "sp-version-proc-macro" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "parity-scale-codec", "proc-macro2", @@ -12220,7 +12229,7 @@ dependencies = [ [[package]] name = "sp-wasm-interface" version = "7.0.0" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "anyhow", "impl-trait-for-tuples", @@ -12235,7 +12244,7 @@ dependencies = [ [[package]] name = "sp-wasm-interface-common" version = "7.0.0" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "parity-scale-codec", "sp-std 5.0.0 (git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox)", @@ -12260,7 +12269,7 @@ dependencies = [ [[package]] name = "sp-weights" version = "4.0.0" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "parity-scale-codec", "scale-info", @@ -12441,7 +12450,7 @@ dependencies = [ [[package]] name = "substrate-build-script-utils" version = "3.0.0" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "platforms 2.0.0", ] @@ -12449,7 +12458,7 @@ dependencies = [ [[package]] name = "substrate-frame-rpc-system" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "frame-system-rpc-runtime-api", "futures", @@ -12468,7 +12477,7 @@ dependencies = [ [[package]] name = "substrate-prometheus-endpoint" version = "0.10.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "hyper", "log", @@ -12480,7 +12489,7 @@ dependencies = [ [[package]] name = "substrate-rpc-client" version = "0.10.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "async-trait", "jsonrpsee", @@ -12493,7 +12502,7 @@ dependencies = [ [[package]] name = "substrate-state-trie-migration-rpc" version = "4.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "jsonrpsee", "log", @@ -12512,7 +12521,7 @@ dependencies = [ [[package]] name = "substrate-test-client" version = "2.0.1" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "array-bytes", "async-trait", @@ -12558,7 +12567,7 @@ dependencies = [ [[package]] name = "substrate-wasm-builder" version = "5.0.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "ansi_term", "build-helper", @@ -13303,7 +13312,7 @@ checksum = "3528ecfd12c466c6f163363caf2d02a71161dd5e1cc6ae7b34207ea2d42d81ed" [[package]] name = "try-runtime-cli" version = "0.10.0-dev" -source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#93aa762a96970dc7d5987a8c890a6be4912f3cd3" +source = "git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox#87bb086be2ef49b8cfbb56ae052c94ef11d64d7b" dependencies = [ "async-trait", "clap 4.4.2", @@ -13579,6 +13588,7 @@ dependencies = [ "pallet-scheduler", "pallet-session", "pallet-staking", + "pallet-staking-runtime-api", "pallet-sudo", "pallet-timestamp", "pallet-transaction-payment", diff --git a/Cargo.toml b/Cargo.toml index 79fd4c5f919..5bd2805a3d0 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -280,6 +280,7 @@ pallet-referenda = { version = "4.0.0-dev", git = "https://github.com/gear-tech/ pallet-scheduler = { version = "4.0.0-dev", git = "https://github.com/gear-tech/substrate.git", branch = "gear-polkadot-v0.9.41-canary-no-sandbox", default-features = false } pallet-session = { version = "4.0.0-dev", git = "https://github.com/gear-tech/substrate.git", branch = "gear-polkadot-v0.9.41-canary-no-sandbox", default-features = false } pallet-staking = { version = "4.0.0-dev", git = "https://github.com/gear-tech/substrate.git", branch = "gear-polkadot-v0.9.41-canary-no-sandbox", default-features = false } +pallet-staking-runtime-api = { version = "4.0.0-dev", git = "https://github.com/gear-tech/substrate.git", branch = "gear-polkadot-v0.9.41-canary-no-sandbox", default-features = false } pallet-staking-reward-fn = { version = "4.0.0-dev", git = "https://github.com/gear-tech/substrate.git", branch = "gear-polkadot-v0.9.41-canary-no-sandbox", default-features = false } pallet-sudo = { version = "4.0.0-dev", git = "https://github.com/gear-tech/substrate.git", branch = "gear-polkadot-v0.9.41-canary-no-sandbox", default-features = false } pallet-timestamp = { version = "4.0.0-dev", git = "https://github.com/gear-tech/substrate.git", branch = "gear-polkadot-v0.9.41-canary-no-sandbox", default-features = false } diff --git a/runtime/vara/Cargo.toml b/runtime/vara/Cargo.toml index e2ebdcdfa69..c9178dd02c7 100644 --- a/runtime/vara/Cargo.toml +++ b/runtime/vara/Cargo.toml @@ -49,6 +49,7 @@ pallet-referenda.workspace = true pallet-scheduler.workspace = true pallet-session = { workspace = true, features = [ "historical" ] } pallet-staking.workspace = true +pallet-staking-runtime-api.workspace = true pallet-sudo = { workspace = true, optional = true } pallet-timestamp.workspace = true pallet-transaction-payment.workspace = true @@ -159,6 +160,7 @@ std = [ "pallet-session/std", "pallet-scheduler/std", "pallet-staking/std", + "pallet-staking-runtime-api/std", "pallet-sudo?/std", "pallet-timestamp/std", "pallet-transaction-payment/std", diff --git a/runtime/vara/src/lib.rs b/runtime/vara/src/lib.rs index fadaac51377..6b8e1038a0f 100644 --- a/runtime/vara/src/lib.rs +++ b/runtime/vara/src/lib.rs @@ -1356,6 +1356,36 @@ impl_runtime_apis_plus_common! { } + impl pallet_nomination_pools_runtime_api::NominationPoolsApi< + Block, + AccountId, + Balance, + > for Runtime { + fn pending_rewards(member: AccountId) -> Balance { + NominationPools::api_pending_rewards(member).unwrap_or_default() + } + + fn points_to_balance(pool_id: pallet_nomination_pools::PoolId, points: Balance) -> Balance { + NominationPools::api_points_to_balance(pool_id, points) + } + + fn balance_to_points(pool_id: pallet_nomination_pools::PoolId, new_funds: Balance) -> Balance { + NominationPools::api_balance_to_points(pool_id, new_funds) + } + } + + impl pallet_staking_runtime_api::StakingApi for Runtime { + fn nominations_quota(balance: Balance) -> u32 { + Staking::api_nominations_quota(balance) + } + } + + impl pallet_gear_staking_rewards_rpc_runtime_api::GearStakingRewardsApi for Runtime { + fn inflation_info() -> pallet_gear_staking_rewards::InflationInfo { + StakingRewards::inflation_info() + } + } + #[cfg(feature = "try-runtime")] impl frame_try_runtime::TryRuntime for Runtime { fn on_runtime_upgrade(checks: frame_try_runtime::UpgradeCheckSelect) -> (Weight, Weight) { @@ -1385,10 +1415,4 @@ impl_runtime_apis_plus_common! { Executive::try_execute_block(block, state_root_check, signature_check, select).unwrap() } } - - impl pallet_gear_staking_rewards_rpc_runtime_api::GearStakingRewardsApi for Runtime { - fn inflation_info() -> pallet_gear_staking_rewards::InflationInfo { - StakingRewards::inflation_info() - } - } } From 71168c5b17c0ddf67cfd5abdadd0940e8a732c94 Mon Sep 17 00:00:00 2001 From: ekovalev Date: Thu, 5 Oct 2023 13:10:59 +0200 Subject: [PATCH 7/8] feat(vara): Maintain total supply consistency in offchain election provider (#3389) --- Cargo.lock | 2 + pallets/staking-rewards/Cargo.toml | 2 + pallets/staking-rewards/src/lib.rs | 8 +- pallets/staking-rewards/src/mock.rs | 134 +++++++++++++++++++++++++-- pallets/staking-rewards/src/tests.rs | 115 +++++++++++++++++++++++ runtime/vara/src/lib.rs | 4 +- 6 files changed, 252 insertions(+), 13 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 076ee790ae9..53cb6a03082 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -7689,6 +7689,7 @@ dependencies = [ "pallet-authorship", "pallet-bags-list", "pallet-balances", + "pallet-election-provider-multi-phase", "pallet-session", "pallet-staking", "pallet-staking-reward-fn", @@ -7703,6 +7704,7 @@ dependencies = [ "sp-authority-discovery", "sp-core 7.0.0 (git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox)", "sp-io 7.0.0 (git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox)", + "sp-npos-elections", "sp-runtime 7.0.0 (git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox)", "sp-std 5.0.0 (git+https://github.com/gear-tech/substrate.git?branch=gear-polkadot-v0.9.41-canary-no-sandbox)", ] diff --git a/pallets/staking-rewards/Cargo.toml b/pallets/staking-rewards/Cargo.toml index 567659a9853..3dd27074128 100644 --- a/pallets/staking-rewards/Cargo.toml +++ b/pallets/staking-rewards/Cargo.toml @@ -33,6 +33,7 @@ pallet-staking-reward-fn.workspace = true sp-core = { workspace = true, features = ["std"] } sp-io = { workspace = true, features = ["std"] } sp-authority-discovery = { workspace = true, features = ["std"] } +sp-npos-elections = { workspace = true, features = ["std"] } frame-election-provider-support = { workspace = true, features = ["std"] } pallet-treasury = { workspace = true, features = ["std"] } pallet-authorship = { workspace = true, features = ["std"] } @@ -41,6 +42,7 @@ pallet-session = { workspace = true, features = ["std"] } pallet-sudo = { workspace = true, features = ["std"] } pallet-bags-list = { workspace = true, features = ["std"] } pallet-utility = { workspace = true, features = ["std"] } +pallet-election-provider-multi-phase = { workspace = true, features = ["std"] } frame-executive = { workspace = true, features = ["std"] } env_logger.workspace = true diff --git a/pallets/staking-rewards/src/lib.rs b/pallets/staking-rewards/src/lib.rs index 039a0ee60df..66fd46e05fb 100644 --- a/pallets/staking-rewards/src/lib.rs +++ b/pallets/staking-rewards/src/lib.rs @@ -428,9 +428,11 @@ impl OnUnbalanced> for Pallet { /// A type to be plugged into the Staking pallet as the `RewardRemainder` associated type. /// -/// Implements the `OnUnbalanced` trait in a way that would try to offset -/// the input negative imbalance against the staking rewards pool so that the total -/// token supply is not affected by the rewards-in-excess that are sent to Treasury. +/// Implements the `OnUnbalanced` trait in a way that would try to burn +/// the amount equivalent to that provided in the input `NegativeImbalance` from the rewards +/// pool in order to keep the token total supply intact. It is assumed that the subsequent +/// `OnUnbalanced` handler (e.g. Treasury) would `resolve` the imbalance and not drop it - +/// otherwise the the total supply will decrease. pub struct RewardsStash(sp_std::marker::PhantomData<(T, U)>); impl OnUnbalanced> for RewardsStash diff --git a/pallets/staking-rewards/src/mock.rs b/pallets/staking-rewards/src/mock.rs index e5037ced27b..e5ca6aad641 100644 --- a/pallets/staking-rewards/src/mock.rs +++ b/pallets/staking-rewards/src/mock.rs @@ -17,16 +17,20 @@ // along with this program. If not, see . use crate as pallet_gear_staking_rewards; -use frame_election_provider_support::{onchain, SequentialPhragmen, VoteWeight}; +use frame_election_provider_support::{ + onchain, ElectionDataProvider, SequentialPhragmen, VoteWeight, +}; use frame_support::{ construct_runtime, parameter_types, traits::{ - ConstU32, Contains, FindAuthor, GenesisBuild, OnFinalize, OnInitialize, U128CurrencyToVote, + ConstU32, Contains, Currency, Everything, FindAuthor, GenesisBuild, NeverEnsureOrigin, + OnFinalize, OnInitialize, U128CurrencyToVote, }, - weights::constants::RocksDbWeight, + weights::{constants::RocksDbWeight, Weight}, PalletId, }; use frame_system::{self as system, pallet_prelude::BlockNumberFor, EnsureRoot}; +use pallet_election_provider_multi_phase::{self as multi_phase}; use pallet_session::historical::{self as pallet_session_historical}; use sp_core::{crypto::key_types, H256}; use sp_runtime::{ @@ -95,6 +99,7 @@ construct_runtime!( BagsList: pallet_bags_list::::{Pallet, Event}, Sudo: pallet_sudo::{Pallet, Call, Storage, Config, Event}, Utility: pallet_utility::{Pallet, Call, Event}, + ElectionProviderMultiPhase: multi_phase::{Pallet, Call, Event}, } ); @@ -117,7 +122,7 @@ parameter_types! { } impl system::Config for Test { - type BaseCallFilter = frame_support::traits::Everything; + type BaseCallFilter = Everything; type BlockWeights = (); type BlockLength = (); type DbWeight = RocksDbWeight; @@ -301,6 +306,16 @@ parameter_types! { pub const MaxOnChainElectableTargets: u16 = 100; } +frame_election_provider_support::generate_solution_type!( + #[compact] + pub struct TestNposSolution::< + VoterIndex = u32, + TargetIndex = u16, + Accuracy = sp_runtime::PerU16, + MaxVoters = ConstU32::<2_000>, + >(16) +); + pub struct OnChainSeqPhragmen; impl onchain::Config for OnChainSeqPhragmen { type System = Test; @@ -414,7 +429,93 @@ impl pallet_treasury::Config for Test { type SpendFunds = (); type WeightInfo = (); type MaxApprovals = MaxApprovals; - type SpendOrigin = frame_support::traits::NeverEnsureOrigin; + type SpendOrigin = NeverEnsureOrigin; +} + +parameter_types! { + // phase durations. 1/4 of the last session for each. + pub static SignedPhase: u64 = SESSION_DURATION / 4; + pub static UnsignedPhase: u64 = SESSION_DURATION / 4; + + // signed config + pub static SignedRewardBase: Balance = 50 * UNITS; + pub static SignedDepositBase: Balance = 50 * UNITS; + pub static SignedDepositByte: Balance = 0; + pub static SignedMaxSubmissions: u32 = 5; + pub static SignedMaxRefunds: u32 = 2; + pub BetterUnsignedThreshold: Perbill = Perbill::zero(); + pub SignedMaxWeight: Weight = Weight::from_parts(u64::MAX, u64::MAX); + + // miner configs + pub static MinerTxPriority: u64 = 100; + pub static MinerMaxWeight: Weight = Weight::from_parts(u64::MAX, u64::MAX); + pub static MinerMaxLength: u32 = 256; +} + +impl multi_phase::MinerConfig for Test { + type AccountId = AccountId; + type MaxLength = MinerMaxLength; + type MaxWeight = MinerMaxWeight; + type MaxVotesPerVoter = ::MaxVotesPerVoter; + type MaxWinners = MaxActiveValidators; + type Solution = TestNposSolution; + + fn solution_weight(v: u32, t: u32, a: u32, d: u32) -> Weight { + <::WeightInfo as multi_phase::WeightInfo>::submit_unsigned( + v, t, a, d, + ) + } +} + +pub struct TestBenchmarkingConfig; +impl multi_phase::BenchmarkingConfig for TestBenchmarkingConfig { + const VOTERS: [u32; 2] = [1000, 2000]; + const TARGETS: [u32; 2] = [500, 1000]; + const ACTIVE_VOTERS: [u32; 2] = [500, 800]; + const DESIRED_TARGETS: [u32; 2] = [200, 400]; + const SNAPSHOT_MAXIMUM_VOTERS: u32 = 1000; + const MINER_MAXIMUM_VOTERS: u32 = 1000; + const MAXIMUM_TARGETS: u32 = 300; +} + +impl multi_phase::Config for Test { + type RuntimeEvent = RuntimeEvent; + type Currency = Balances; + type EstimateCallFee = ConstU32<1_000>; + type SignedPhase = SignedPhase; + type UnsignedPhase = UnsignedPhase; + type BetterUnsignedThreshold = BetterUnsignedThreshold; + type BetterSignedThreshold = (); + type OffchainRepeat = OffchainRepeat; + type MinerTxPriority = MinerTxPriority; + type SignedRewardBase = SignedRewardBase; + type SignedDepositBase = SignedDepositBase; + type SignedDepositByte = (); + type SignedDepositWeight = (); + type SignedMaxWeight = SignedMaxWeight; + type SignedMaxSubmissions = SignedMaxSubmissions; + type SignedMaxRefunds = SignedMaxRefunds; + type SlashHandler = Treasury; + type RewardHandler = StakingRewards; + type DataProvider = Staking; + type Fallback = onchain::OnChainExecution; + type GovernanceFallback = onchain::OnChainExecution; + type ForceOrigin = frame_system::EnsureRoot; + type MaxElectableTargets = MaxElectableTargets; + type MaxWinners = MaxActiveValidators; + type MaxElectingVoters = MaxElectingVoters; + type WeightInfo = (); + type BenchmarkingConfig = TestBenchmarkingConfig; + type MinerConfig = Self; + type Solver = SequentialPhragmen, ()>; +} + +impl frame_system::offchain::SendTransactionTypes for Test +where + RuntimeCall: From, +{ + type OverarchingCall = RuntimeCall; + type Extrinsic = TestXt; } pub type ValidatorAccountId = ( @@ -573,9 +674,7 @@ impl ExtBuilder { if total_supply < self.total_supply { // Mint the difference to SIGNER user let diff = self.total_supply.saturating_sub(total_supply); - let _ = >::deposit_creating( - &SIGNER, diff, - ); + let _ = >::deposit_creating(&SIGNER, diff); } }); ext @@ -607,11 +706,30 @@ pub(crate) fn run_for_n_blocks(n: u64) { } } +pub fn run_to_unsigned() { + while !matches!( + ElectionProviderMultiPhase::current_phase(), + multi_phase::Phase::Unsigned(_) + ) { + run_to_block(System::block_number() + 1); + } +} + +pub fn run_to_signed() { + while !matches!( + ElectionProviderMultiPhase::current_phase(), + multi_phase::Phase::Signed + ) { + run_to_block(System::block_number() + 1); + } +} + // Run on_initialize hooks in order as they appear in AllPalletsWithSystem. pub(crate) fn on_initialize(new_block_number: BlockNumberFor) { Timestamp::set_timestamp(new_block_number.saturating_mul(MILLISECS_PER_BLOCK)); Authorship::on_initialize(new_block_number); Session::on_initialize(new_block_number); + ElectionProviderMultiPhase::on_initialize(new_block_number); } // Run on_finalize hooks (in pallets reverse order, as they appear in AllPalletsWithSystem) diff --git a/pallets/staking-rewards/src/tests.rs b/pallets/staking-rewards/src/tests.rs index e1f1a230ff7..e2942765929 100644 --- a/pallets/staking-rewards/src/tests.rs +++ b/pallets/staking-rewards/src/tests.rs @@ -1234,6 +1234,121 @@ fn empty_rewards_pool_causes_inflation() { }); } +#[test] +fn election_solution_rewards_add_up() { + use pallet_election_provider_multi_phase::{Config as MPConfig, RawSolution}; + use sp_npos_elections::ElectionScore; + + let (target_inflation, ideal_stake, pool_balance, non_stakeable) = sensible_defaults(); + // Solutions submitters + let accounts = (0_u64..5).map(|i| 100 + i).collect::>(); + let mut ext = ExtBuilder::default() + .initial_authorities(vec![ + (VAL_1_STASH, VAL_1_CONTROLLER, VAL_1_AUTH_ID), + (VAL_2_STASH, VAL_2_CONTROLLER, VAL_2_AUTH_ID), + (VAL_3_STASH, VAL_3_CONTROLLER, VAL_3_AUTH_ID), + ]) + .stash(VALIDATOR_STAKE) + .endowment(ENDOWMENT) + .endowed_accounts(accounts) + .total_supply(INITIAL_TOTAL_TOKEN_SUPPLY) + .non_stakeable(non_stakeable) + .pool_balance(pool_balance) + .ideal_stake(ideal_stake) + .target_inflation(target_inflation) + .build(); + ext.execute_with(|| { + // Initial chain state + let (initial_total_issuance, _, initial_treasury_balance, initial_rewards_pool_balance) = + chain_state(); + assert_eq!(initial_rewards_pool_balance, pool_balance); + + // Running chain until the signing phase begins + run_to_signed(); + assert!(ElectionProviderMultiPhase::current_phase().is_signed()); + assert_eq!(::SignedMaxRefunds::get(), 2_u32); + assert!(::SignedMaxSubmissions::get() > 3_u32); + + // Submit 3 election solutions candidates: + // 2 good solutions and 1 incorrect one (with higher score, so that it is going to run + // through feasibility check as the best candidate but eventually be rejected and slashed). + let good_solution = RawSolution { + solution: TestNposSolution { + votes1: vec![(0, 0), (1, 1), (2, 2)], + ..Default::default() + }, + score: ElectionScore { + minimal_stake: VALIDATOR_STAKE, + sum_stake: 3 * VALIDATOR_STAKE, + sum_stake_squared: 3 * VALIDATOR_STAKE * VALIDATOR_STAKE, + }, + round: 1, + }; + let bad_solution = RawSolution { + solution: TestNposSolution { + votes1: vec![(0, 0), (1, 1), (2, 2)], + ..Default::default() + }, + score: ElectionScore { + minimal_stake: VALIDATOR_STAKE + 100_u128, + sum_stake: 3 * VALIDATOR_STAKE, + sum_stake_squared: 3 * VALIDATOR_STAKE * VALIDATOR_STAKE, + }, + round: 1, + }; + let solutions = vec![good_solution.clone(), bad_solution, good_solution]; + for (i, s) in solutions.into_iter().enumerate() { + let account = 100_u64 + i as u64; + assert_ok!(ElectionProviderMultiPhase::submit( + RuntimeOrigin::signed(account), + Box::new(s) + )); + assert_eq!( + Balances::free_balance(account), + ENDOWMENT - ::SignedDepositBase::get() + ); + } + + run_to_unsigned(); + + // Measure current stats + let (total_issuance, _, treasury_balance, rewards_pool_balance) = chain_state(); + + // Check all balances consistency: + // 1. `total_issuance` hasn't change despite rewards having been minted + assert_eq!(total_issuance, initial_total_issuance); + // 2. the account whose solution was accepted got reward + tx fee rebate + assert_eq!( + Balances::free_balance(102), + ENDOWMENT + + ::SignedRewardBase::get() + + <::EstimateCallFee as Get>::get() as u128 + ); + // 3. the account whose solution was rejected got slashed and lost the deposit and fee + assert_eq!( + Balances::free_balance(101), + ENDOWMENT - ::SignedDepositBase::get() + ); + // 4. the third account got deposit unreserved and tx fee returned + assert_eq!( + Balances::free_balance(100), + ENDOWMENT + <::EstimateCallFee as Get>::get() as u128 + ); + // 5. the slashed deposit went to `Treasury` + assert_eq!( + treasury_balance, + initial_treasury_balance + ::SignedDepositBase::get() + ); + // 6. the rewards offset pool's balanced decreased to compensate for reward and rebates. + assert_eq!( + rewards_pool_balance, + initial_rewards_pool_balance + - ::SignedRewardBase::get() + - <::EstimateCallFee as Get>::get() as u128 * 2 + ); + }); +} + fn sensible_defaults() -> (Perquintill, Perquintill, u128, Perquintill) { ( Perquintill::from_rational(578_u64, 10_000_u64), diff --git a/runtime/vara/src/lib.rs b/runtime/vara/src/lib.rs index 6b8e1038a0f..e3d33b36656 100644 --- a/runtime/vara/src/lib.rs +++ b/runtime/vara/src/lib.rs @@ -555,8 +555,8 @@ impl pallet_election_provider_multi_phase::Config for Runtime { type SignedMaxRefunds = ConstU32<3>; type SignedDepositWeight = (); type SignedMaxWeight = MinerMaxWeight; - type SlashHandler = (); // burn slashes - type RewardHandler = (); // nothing to do upon rewards + type SlashHandler = Treasury; + type RewardHandler = StakingRewards; type DataProvider = Staking; type Fallback = onchain::OnChainExecution; type GovernanceFallback = onchain::OnChainExecution; From 77d537ff25d36899ddb0ae50a42f285e5bc9478d Mon Sep 17 00:00:00 2001 From: Vadim Smirnov Date: Mon, 9 Oct 2023 10:44:41 +0500 Subject: [PATCH 8/8] feat(vara): add TransactionPaymentCallApi (#3393) --- runtime/vara/src/lib.rs | 21 ++++++++++++++++++++- 1 file changed, 20 insertions(+), 1 deletion(-) diff --git a/runtime/vara/src/lib.rs b/runtime/vara/src/lib.rs index e3d33b36656..76635c44a70 100644 --- a/runtime/vara/src/lib.rs +++ b/runtime/vara/src/lib.rs @@ -63,7 +63,9 @@ use pallet_grandpa::{ use pallet_im_online::sr25519::AuthorityId as ImOnlineId; use pallet_session::historical::{self as pallet_session_historical}; pub use pallet_timestamp::Call as TimestampCall; -pub use pallet_transaction_payment::{CurrencyAdapter, Multiplier}; +pub use pallet_transaction_payment::{ + CurrencyAdapter, FeeDetails, Multiplier, RuntimeDispatchInfo, +}; use runtime_common::constants::BANK_ADDRESS; pub use runtime_common::{ constants::{ @@ -1356,6 +1358,23 @@ impl_runtime_apis_plus_common! { } + impl pallet_transaction_payment_rpc_runtime_api::TransactionPaymentCallApi + for Runtime + { + fn query_call_info(call: RuntimeCall, len: u32) -> RuntimeDispatchInfo { + TransactionPayment::query_call_info(call, len) + } + fn query_call_fee_details(call: RuntimeCall, len: u32) -> FeeDetails { + TransactionPayment::query_call_fee_details(call, len) + } + fn query_weight_to_fee(weight: Weight) -> Balance { + TransactionPayment::weight_to_fee(weight) + } + fn query_length_to_fee(length: u32) -> Balance { + TransactionPayment::length_to_fee(length) + } + } + impl pallet_nomination_pools_runtime_api::NominationPoolsApi< Block, AccountId,