pezkuwichain/pezkuwi-subxt
1
0
Fork 0
mirror of https://github.com/pezkuwichain/pezkuwi-subxt.git synced 2026-06-12 10:01:17 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fix spelling mistakes across the whole repository (#3808)

Browse Source 
**Update:** Pushed additional changes based on the review comments.

**This pull request fixes various spelling mistakes in this
repository.**

Most of the changes are contained in the first **3** commits:

- `Fix spelling mistakes in comments and docs`

- `Fix spelling mistakes in test names`

- `Fix spelling mistakes in error messages, panic messages, logs and
tracing`

Other source code spelling mistakes are separated into individual
commits for easier reviewing:

- `Fix the spelling of 'authority'`

- `Fix the spelling of 'REASONABLE_HEADERS_IN_JUSTIFICATION_ANCESTRY'`

- `Fix the spelling of 'prev_enqueud_messages'`

- `Fix the spelling of 'endpoint'`

- `Fix the spelling of 'children'`

- `Fix the spelling of 'PenpalSiblingSovereignAccount'`

- `Fix the spelling of 'PenpalSudoAccount'`

- `Fix the spelling of 'insufficient'`

- `Fix the spelling of 'PalletXcmExtrinsicsBenchmark'`

- `Fix the spelling of 'subtracted'`

- `Fix the spelling of 'CandidatePendingAvailability'`

- `Fix the spelling of 'exclusive'`

- `Fix the spelling of 'until'`

- `Fix the spelling of 'discriminator'`

- `Fix the spelling of 'nonexistent'`

- `Fix the spelling of 'subsystem'`

- `Fix the spelling of 'indices'`

- `Fix the spelling of 'committed'`

- `Fix the spelling of 'topology'`

- `Fix the spelling of 'response'`

- `Fix the spelling of 'beneficiary'`

- `Fix the spelling of 'formatted'`

- `Fix the spelling of 'UNKNOWN_PROOF_REQUEST'`

- `Fix the spelling of 'succeeded'`

- `Fix the spelling of 'reopened'`

- `Fix the spelling of 'proposer'`

- `Fix the spelling of 'InstantiationNonce'`

- `Fix the spelling of 'depositor'`

- `Fix the spelling of 'expiration'`

- `Fix the spelling of 'phantom'`

- `Fix the spelling of 'AggregatedKeyValue'`

- `Fix the spelling of 'randomness'`

- `Fix the spelling of 'defendant'`

- `Fix the spelling of 'AquaticMammal'`

- `Fix the spelling of 'transactions'`

- `Fix the spelling of 'PassingTracingSubscriber'`

- `Fix the spelling of 'TxSignaturePayload'`

- `Fix the spelling of 'versioning'`

- `Fix the spelling of 'descendant'`

- `Fix the spelling of 'overridden'`

- `Fix the spelling of 'network'`

Let me know if this structure is adequate.

**Note:** The usage of the words `Merkle`, `Merkelize`, `Merklization`,
`Merkelization`, `Merkleization`, is somewhat inconsistent but I left it
as it is.

~~**Note:** In some places the term `Receival` is used to refer to
message reception, IMO `Reception` is the correct word here, but I left
it as it is.~~

~~**Note:** In some places the term `Overlayed` is used instead of the
more acceptable version `Overlaid` but I also left it as it is.~~

~~**Note:** In some places the term `Applyable` is used instead of the
correct version `Applicable` but I also left it as it is.~~

**Note:** Some usage of British vs American english e.g. `judgement` vs
`judgment`, `initialise` vs `initialize`, `optimise` vs `optimize` etc.
are both present in different places, but I suppose that's
understandable given the number of contributors.

~~**Note:** There is a spelling mistake in `.github/CODEOWNERS` but it
triggers errors in CI when I make changes to it, so I left it as it
is.~~
This commit is contained in:
Dcompoze
2024-03-26 13:57:57 +00:00
committed by GitHub
parent b839c995c0
commit 002d9260f9
463 changed files with 1119 additions and 1017 deletions
Download Patch File Download Diff File Expand all files Collapse all files
polkadot/node/subsystem-bench/src/lib/approval/message_generator.rs
+5 -5
View File
@@ -74,8 +74,8 @@ pub struct PeerMessagesGenerator {
pub validator_index: ValidatorIndex,
/// An array of pre-generated random samplings, that is used to determine, which nodes would
/// send a given assignment, to the node under test because of the random samplings.
/// As an optimization we generate this sampling at the begining of the test and just pick
/// one randomly, because always taking the samples would be too expensive for benchamrk.
/// As an optimization we generate this sampling at the beginning of the test and just pick
/// one randomly, because always taking the samples would be too expensive for benchmark.
pub random_samplings: Vec<Vec<ValidatorIndex>>,
/// Channel for sending the generated messages to the aggregator
pub tx_messages: futures::channel::mpsc::UnboundedSender<(Hash, Vec<MessagesBundle>)>,
@@ -234,7 +234,7 @@ impl PeerMessagesGenerator {
let all_messages = all_messages
.into_iter()
.flat_map(|(_, mut messages)| {
// Shuffle the messages inside the same tick, so that we don't priorites messages
// Shuffle the messages inside the same tick, so that we don't priorities messages
// for older nodes. we try to simulate the same behaviour as in real world.
messages.shuffle(&mut rand_chacha);
messages
@@ -560,12 +560,12 @@ struct TestSignInfo {
candidate_index: CandidateIndex,
/// The validator sending the assignments
validator_index: ValidatorIndex,
/// The assignments convering this candidate
/// The assignments covering this candidate
assignment: TestMessageInfo,
}
impl TestSignInfo {
/// Helper function to create a signture for all candidates in `to_sign` parameter.
/// Helper function to create a signature for all candidates in `to_sign` parameter.
/// Returns a TestMessage
fn sign_candidates(
to_sign: &mut Vec<TestSignInfo>,
polkadot/node/subsystem-bench/src/lib/approval/mod.rs
+8 -8
View File
@@ -115,7 +115,7 @@ pub struct ApprovalsOptions {
#[clap(short, long, default_value_t = 1.0)]
/// Max candidate to be signed in a single approval.
pub coalesce_std_dev: f32,
/// The maximum tranche diff between approvals coalesced toghther.
/// The maximum tranche diff between approvals coalesced together.
pub coalesce_tranche_diff: u32,
#[clap(short, long, default_value_t = false)]
/// Enable assignments v2.
@@ -170,7 +170,7 @@ struct BlockTestData {
total_candidates_before: u64,
/// The votes we sent.
/// votes[validator_index][candidate_index] tells if validator sent vote for candidate.
/// We use this to mark the test as succesfull if GetApprovalSignatures returns all the votes
/// We use this to mark the test as successful if GetApprovalSignatures returns all the votes
/// from here.
votes: Arc<Vec<Vec<AtomicBool>>>,
}
@@ -237,7 +237,7 @@ struct GeneratedState {
}
/// Approval test state used by all mock subsystems to be able to answer messages emitted
/// by the approval-voting and approval-distribution-subystems.
/// by the approval-voting and approval-distribution-subsystems.
///
/// This gets cloned across all mock subsystems, so if there is any information that gets
/// updated between subsystems, they would have to be wrapped in Arc's.
@@ -498,7 +498,7 @@ struct PeerMessageProducer {
impl PeerMessageProducer {
/// Generates messages by spawning a blocking task in the background which begins creating
/// the assignments/approvals and peer view changes at the begining of each block.
/// the assignments/approvals and peer view changes at the beginning of each block.
fn produce_messages(
mut self,
env: &TestEnvironment,
@@ -740,7 +740,7 @@ impl PeerMessageProducer {
}
}
// Initializes the candidates test data. This is used for bookeeping if more assignments and
// Initializes the candidates test data. This is used for bookkeeping if more assignments and
// approvals would be needed.
fn initialize_candidates_test_data(
&self,
@@ -767,7 +767,7 @@ impl PeerMessageProducer {
}
/// Helper function to build an overseer with the real implementation for `ApprovalDistribution` and
/// `ApprovalVoting` subystems and mock subsytems for all others.
/// `ApprovalVoting` subsystems and mock subsystems for all others.
fn build_overseer(
state: &ApprovalTestState,
network: &NetworkEmulatorHandle,
@@ -936,7 +936,7 @@ pub async fn bench_approvals_run(
for block_num in 0..env.config().num_blocks {
let mut current_slot = tick_to_slot_number(SLOT_DURATION_MILLIS, system_clock.tick_now());
// Wait untill the time arrieves at the first slot under test.
// Wait until the time arrives at the first slot under test.
while current_slot < state.generated_state.initial_slot {
sleep(Duration::from_millis(5)).await;
current_slot = tick_to_slot_number(SLOT_DURATION_MILLIS, system_clock.tick_now());
@@ -961,7 +961,7 @@ pub async fn bench_approvals_run(
}
// Wait for all blocks to be approved before exiting.
// This is an invariant of the benchmark, if this does not happen something went teribbly wrong.
// This is an invariant of the benchmark, if this does not happen something went terribly wrong.
while state.last_approved_block.load(std::sync::atomic::Ordering::SeqCst) <
env.config().num_blocks as u32
{
polkadot/node/subsystem-bench/src/lib/approval/test_message.rs
+7 -7
View File
@@ -31,7 +31,7 @@ pub struct TestMessageInfo {
pub msg: protocol_v3::ApprovalDistributionMessage,
/// The list of peers that would sends this message in a real topology.
/// It includes both the peers that would send the message because of the topology
/// or because of randomly chosing so.
/// or because of randomly choosing so.
pub sent_by: Vec<ValidatorIndex>,
/// The tranche at which this message should be sent.
pub tranche: u32,
@@ -90,7 +90,7 @@ impl MessagesBundle {
/// Tells if the bundle is needed for sending.
/// We either send it because we need more assignments and approvals to approve the candidates
/// or because we configured the test to send messages untill a given tranche.
/// or because we configured the test to send messages until a given tranche.
pub fn should_send(
&self,
candidates_test_data: &HashMap<(Hash, CandidateIndex), CandidateTestData>,
@@ -174,24 +174,24 @@ impl TestMessageInfo {
}
}
/// Returns a list of candidates indicies in this message
/// Returns a list of candidates indices in this message
pub fn candidate_indices(&self) -> HashSet<usize> {
let mut unique_candidate_indicies = HashSet::new();
let mut unique_candidate_indices = HashSet::new();
match &self.msg {
protocol_v3::ApprovalDistributionMessage::Assignments(assignments) =>
for (_assignment, candidate_indices) in assignments {
for candidate_index in candidate_indices.iter_ones() {
unique_candidate_indicies.insert(candidate_index);
unique_candidate_indices.insert(candidate_index);
}
},
protocol_v3::ApprovalDistributionMessage::Approvals(approvals) =>
for approval in approvals {
for candidate_index in approval.candidate_indices.iter_ones() {
unique_candidate_indicies.insert(candidate_index);
unique_candidate_indices.insert(candidate_index);
}
},
}
unique_candidate_indicies
unique_candidate_indices
}
/// Marks this message as no-shows if the number of configured no-shows is above the registered
polkadot/node/subsystem-bench/src/lib/availability/mod.rs
+3 -3
View File
@@ -69,7 +69,7 @@ const LOG_TARGET: &str = "subsystem-bench::availability";
pub struct DataAvailabilityReadOptions {
#[clap(short, long, default_value_t = false)]
/// Turbo boost AD Read by fetching the full availability datafrom backers first. Saves CPU as
/// we don't need to re-construct from chunks. Tipically this is only faster if nodes have
/// we don't need to re-construct from chunks. Typically this is only faster if nodes have
/// enough bandwidth.
pub fetch_from_backers: bool,
}
@@ -404,7 +404,7 @@ pub async fn benchmark_availability_write(
let network = env.network().clone();
let authorities = env.authorities().clone();
// Spawn a task that will generate `n_validator` - 1 signed bitfiends and
// Spawn a task that will generate `n_validator` - 1 signed bitfields and
// send them from the emulated peers to the subsystem.
// TODO: Implement topology.
let messages = state.signed_bitfields.get(&relay_block_hash).expect("pregenerated").clone();
@@ -425,7 +425,7 @@ pub async fn benchmark_availability_write(
// Wait for all bitfields to be processed.
env.wait_until_metric(
"polkadot_parachain_received_availabilty_bitfields_total",
"polkadot_parachain_received_availability_bitfields_total",
None,
|value| value == (config.connected_count() * block_num) as f64,
)
polkadot/node/subsystem-bench/src/lib/configuration.rs
+3 -3
View File
@@ -122,10 +122,10 @@ pub struct TestConfiguration {
/// Randomly sampled pov_sizes
#[serde(skip)]
pub pov_sizes: Vec<usize>,
/// The amount of bandiwdth remote validators have.
/// The amount of bandwidth remote validators have.
#[serde(default = "default_bandwidth")]
pub peer_bandwidth: usize,
/// The amount of bandiwdth our node has.
/// The amount of bandwidth our node has.
#[serde(default = "default_bandwidth")]
pub bandwidth: usize,
/// Optional peer emulation latency (round trip time) wrt node under test
@@ -205,7 +205,7 @@ impl TestConfiguration {
let peer_id_to_authority = peer_ids
.iter()
.zip(validator_authority_id.iter())
.map(|(peer_id, authorithy_id)| (*peer_id, authorithy_id.clone()))
.map(|(peer_id, authority_id)| (*peer_id, authority_id.clone()))
.collect();
TestAuthorities {
polkadot/node/subsystem-bench/src/lib/mock/av_store.rs
+1 -1
View File
@@ -39,7 +39,7 @@ pub struct AvailabilityStoreState {
const LOG_TARGET: &str = "subsystem-bench::av-store-mock";
/// Mockup helper. Contains Ccunks and full availability data of all parachain blocks
/// Mockup helper. Contains Chunks and full availability data of all parachain blocks
/// used in a test.
#[derive(Clone)]
pub struct NetworkAvailabilityState {
polkadot/node/subsystem-bench/src/lib/mock/chain_api.rs
+1 -1
View File
@@ -89,7 +89,7 @@ impl MockChainApi {
let hash = self
.state
.get_header_by_number(requested_number)
.expect("Unknow block number")
.expect("Unknown block number")
.hash();
sender.send(Ok(Some(hash))).unwrap();
},
polkadot/node/subsystem-bench/src/lib/mock/network_bridge.rs
+6 -6
View File
@@ -42,8 +42,8 @@ pub struct MockNetworkBridgeTx {
network: NetworkEmulatorHandle,
/// A channel to the network interface,
to_network_interface: UnboundedSender<NetworkMessage>,
/// Test authorithies
test_authorithies: TestAuthorities,
/// Test authorities
test_authorities: TestAuthorities,
}
/// A mock of the network bridge tx subsystem.
@@ -58,9 +58,9 @@ impl MockNetworkBridgeTx {
pub fn new(
network: NetworkEmulatorHandle,
to_network_interface: UnboundedSender<NetworkMessage>,
test_authorithies: TestAuthorities,
test_authorities: TestAuthorities,
) -> MockNetworkBridgeTx {
Self { network, to_network_interface, test_authorithies }
Self { network, to_network_interface, test_authorities }
}
}
@@ -125,13 +125,13 @@ impl MockNetworkBridgeTx {
}
},
NetworkBridgeTxMessage::ReportPeer(_) => {
// ingore rep changes
// ignore rep changes
},
NetworkBridgeTxMessage::SendValidationMessage(peers, message) => {
for peer in peers {
self.to_network_interface
.unbounded_send(NetworkMessage::MessageFromNode(
self.test_authorithies
self.test_authorities
.peer_id_to_authority
.get(&peer)
.unwrap()
polkadot/node/subsystem-bench/src/lib/network.rs
+5 -5
View File
@@ -154,7 +154,7 @@ pub enum NetworkMessage {
MessageFromNode(AuthorityDiscoveryId, VersionedValidationProtocol),
/// A request originating from our node
RequestFromNode(AuthorityDiscoveryId, Requests),
/// A request originating from an emultated peer
/// A request originating from an emulated peer
RequestFromPeer(IncomingRequest),
}
@@ -790,9 +790,9 @@ pub fn new_network(
let connected_count = config.connected_count();
let mut peers_indicies = (0..n_peers).collect_vec();
let mut peers_indices = (0..n_peers).collect_vec();
let (_connected, to_disconnect) =
peers_indicies.partial_shuffle(&mut thread_rng(), connected_count);
peers_indices.partial_shuffle(&mut thread_rng(), connected_count);
// Node under test is always mark as disconnected.
peers[NODE_UNDER_TEST as usize].disconnect();
@@ -958,7 +958,7 @@ impl Metrics {
.inc_by(bytes as u64);
}
/// Increment total receioved for a peer.
/// Increment total received for a peer.
pub fn on_peer_received(&self, peer_index: usize, bytes: usize) {
self.peer_total_received
.with_label_values(vec![format!("node{}", peer_index).as_str()].as_slice())
@@ -1041,7 +1041,7 @@ mod tests {
async fn test_expected_rate() {
let tick_rate = 200;
let budget = 1_000_000;
// rate must not exceeed 100 credits per second
// rate must not exceed 100 credits per second
let mut rate_limiter = RateLimit::new(tick_rate, budget);
let mut total_sent = 0usize;
let start = Instant::now();
polkadot/node/subsystem-bench/src/lib/utils.rs
+76
View File
@@ -0,0 +1,76 @@
// Copyright (C) Parity Technologies (UK) Ltd.
// This file is part of Polkadot.
// Polkadot is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// Polkadot is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with Polkadot. If not, see <http://www.gnu.org/licenses/>.
//! Test utils
use crate::usage::BenchmarkUsage;
use std::io::{stdout, Write};
pub struct WarmUpOptions<'a> {
/// The maximum number of runs considered for warming up.
pub warm_up: usize,
/// The number of runs considered for benchmarking.
pub bench: usize,
/// The difference in CPU usage between runs considered as normal
pub precision: f64,
/// The subsystems whose CPU usage is checked during warm-up cycles
pub subsystems: &'a [&'a str],
}
impl<'a> WarmUpOptions<'a> {
pub fn new(subsystems: &'a [&'a str]) -> Self {
Self { warm_up: 100, bench: 3, precision: 0.02, subsystems }
}
}
pub fn warm_up_and_benchmark(
options: WarmUpOptions,
run: impl Fn() -> BenchmarkUsage,
) -> Result<BenchmarkUsage, String> {
println!("Warming up...");
let mut usages = Vec::with_capacity(options.bench);
for n in 1..=options.warm_up {
let curr = run();
if let Some(prev) = usages.last() {
let diffs = options
.subsystems
.iter()
.map(|&v| {
curr.cpu_usage_diff(prev, v)
.ok_or(format!("{} not found in benchmark {:?}", v, prev))
})
.collect::<Result<Vec<f64>, String>>()?;
if !diffs.iter().all(|&v| v < options.precision) {
usages.clear();
}
}
usages.push(curr);
print!("\r{}%", n * 100 / options.warm_up);
if usages.len() == options.bench {
println!("\rTook {} runs to warm up", n.saturating_sub(options.bench));
break;
}
stdout().flush().unwrap();
}
if usages.len() != options.bench {
println!("Didn't warm up after {} runs", options.warm_up);
return Err("Can't warm up".to_string())
}
Ok(BenchmarkUsage::average(&usages))
}