From 2a93147b1b189791930167962cd3671120f21017 Mon Sep 17 00:00:00 2001 From: "mergify[bot]" <37929162+mergify[bot]@users.noreply.github.com> Date: Fri, 16 Jul 2021 22:12:04 +0200 Subject: [PATCH] Add voting service (#18552) (#18722) Co-authored-by: sakridge --- core/src/lib.rs | 1 + core/src/replay_stage.rs | 77 +++++++++++++++++++++++-------------- core/src/tvu.rs | 9 +++++ core/src/voting_service.rs | 79 ++++++++++++++++++++++++++++++++++++++ 4 files changed, 138 insertions(+), 28 deletions(-) create mode 100644 core/src/voting_service.rs diff --git a/core/src/lib.rs b/core/src/lib.rs index b0a2055d42..88fa14dd07 100644 --- a/core/src/lib.rs +++ b/core/src/lib.rs @@ -54,6 +54,7 @@ pub mod unfrozen_gossip_verified_vote_hashes; pub mod validator; pub mod verified_vote_packets; pub mod vote_stake_tracker; +pub mod voting_service; pub mod window_service; #[macro_use] diff --git a/core/src/replay_stage.rs b/core/src/replay_stage.rs index 3af2c59b26..876359650b 100644 --- a/core/src/replay_stage.rs +++ b/core/src/replay_stage.rs @@ -21,6 +21,7 @@ use crate::{ result::Result, rewards_recorder_service::RewardsRecorderSender, unfrozen_gossip_verified_vote_hashes::UnfrozenGossipVerifiedVoteHashes, + voting_service::VoteOp, window_service::DuplicateSlotReceiver, }; use solana_client::rpc_response::SlotUpdate; @@ -309,6 +310,7 @@ impl ReplayStage { gossip_duplicate_confirmed_slots_receiver: GossipDuplicateConfirmedSlotsReceiver, gossip_verified_vote_hash_receiver: GossipVerifiedVoteHashReceiver, cluster_slots_update_sender: ClusterSlotsUpdateSender, + voting_sender: Sender, ) -> Self { let ReplayStageConfig { my_pubkey, @@ -513,12 +515,14 @@ impl ReplayStage { if let Some(my_latest_landed_vote) = progress.my_latest_landed_vote(heaviest_bank_on_same_voted_fork.slot()) { Self::refresh_last_vote(&mut tower, &cluster_info, heaviest_bank_on_same_voted_fork, - &poh_recorder, my_latest_landed_vote, + my_latest_landed_vote, &vote_account, &authorized_voter_keypairs.read().unwrap(), &mut voted_signatures, has_new_vote_been_rooted, &mut - last_vote_refresh_time); + last_vote_refresh_time, + &voting_sender, + ); } } @@ -576,7 +580,6 @@ impl ReplayStage { Self::handle_votable_bank( vote_bank, - &poh_recorder, switch_fork_decision, &bank_forks, &mut tower, @@ -599,6 +602,7 @@ impl ReplayStage { &mut voted_signatures, &mut has_new_vote_been_rooted, &mut replay_timing, + &voting_sender, ); }; voting_time.stop(); @@ -1285,7 +1289,6 @@ impl ReplayStage { #[allow(clippy::too_many_arguments)] fn handle_votable_bank( bank: &Arc, - poh_recorder: &Arc>, switch_fork_decision: &SwitchForkDecision, bank_forks: &Arc>, tower: &mut Tower, @@ -1308,6 +1311,7 @@ impl ReplayStage { vote_signatures: &mut Vec, has_new_vote_been_rooted: &mut bool, replay_timing: &mut ReplayTiming, + voting_sender: &Sender, ) { if bank.is_empty() { inc_new_counter_info!("replay_stage-voted_empty_bank", 1); @@ -1385,7 +1389,6 @@ impl ReplayStage { Self::push_vote( cluster_info, bank, - poh_recorder, vote_account_pubkey, authorized_voter_keypairs, tower, @@ -1393,6 +1396,7 @@ impl ReplayStage { vote_signatures, *has_new_vote_been_rooted, replay_timing, + voting_sender, ); } @@ -1486,13 +1490,13 @@ impl ReplayStage { tower: &mut Tower, cluster_info: &ClusterInfo, heaviest_bank_on_same_fork: &Bank, - poh_recorder: &Mutex, my_latest_landed_vote: Slot, vote_account_pubkey: &Pubkey, authorized_voter_keypairs: &[Arc], vote_signatures: &mut Vec, has_new_vote_been_rooted: bool, last_vote_refresh_time: &mut LastVoteRefreshTime, + voting_sender: &Sender, ) { let last_voted_slot = tower.last_voted_slot(); if last_voted_slot.is_none() { @@ -1549,11 +1553,12 @@ impl ReplayStage { ("target_bank_slot", heaviest_bank_on_same_fork.slot(), i64), ("target_bank_hash", hash_string, String), ); - let _ = cluster_info.send_vote( - &vote_tx, - crate::banking_stage::next_leader_tpu(cluster_info, poh_recorder), - ); - cluster_info.refresh_vote(vote_tx, last_voted_slot); + voting_sender + .send(VoteOp::RefreshVote { + tx: vote_tx, + last_voted_slot, + }) + .unwrap_or_else(|err| warn!("Error: {:?}", err)); last_vote_refresh_time.last_refresh_time = Instant::now(); } } @@ -1562,7 +1567,6 @@ impl ReplayStage { fn push_vote( cluster_info: &ClusterInfo, bank: &Bank, - poh_recorder: &Mutex, vote_account_pubkey: &Pubkey, authorized_voter_keypairs: &[Arc], tower: &mut Tower, @@ -1570,6 +1574,7 @@ impl ReplayStage { vote_signatures: &mut Vec, has_new_vote_been_rooted: bool, replay_timing: &mut ReplayTiming, + voting_sender: &Sender, ) { let mut generate_time = Measure::start("generate_vote"); let vote_tx = Self::generate_vote_tx( @@ -1586,16 +1591,14 @@ impl ReplayStage { replay_timing.generate_vote_us += generate_time.as_us(); if let Some(vote_tx) = vote_tx { tower.refresh_last_vote_tx_blockhash(vote_tx.message.recent_blockhash); - let mut send_time = Measure::start("send_vote"); - let _ = cluster_info.send_vote( - &vote_tx, - crate::banking_stage::next_leader_tpu(cluster_info, poh_recorder), - ); - send_time.stop(); - let mut push_time = Measure::start("push_vote"); - cluster_info.push_vote(&tower.tower_slots(), vote_tx); - push_time.stop(); - replay_timing.vote_push_us += push_time.as_us(); + + let tower_slots = tower.tower_slots(); + voting_sender + .send(VoteOp::PushVote { + tx: vote_tx, + tower_slots, + }) + .unwrap_or_else(|err| warn!("Error: {:?}", err)); } } @@ -2546,6 +2549,7 @@ mod tests { vote_state::{VoteState, VoteStateVersions}, vote_transaction, }; + use std::sync::mpsc::channel; use std::{ fs::remove_dir_all, iter, @@ -4672,6 +4676,7 @@ mod tests { } } } + let (voting_sender, voting_receiver) = channel(); // Simulate landing a vote for slot 0 landing in slot 1 let bank1 = Arc::new(Bank::new_from_parent(&bank0, &Pubkey::default(), 1)); @@ -4680,7 +4685,6 @@ mod tests { ReplayStage::push_vote( &cluster_info, &bank0, - &poh_recorder, &my_vote_pubkey, &my_vote_keypair, &mut tower, @@ -4688,7 +4692,13 @@ mod tests { &mut voted_signatures, has_new_vote_been_rooted, &mut ReplayTiming::default(), + &voting_sender, ); + let vote_info = voting_receiver + .recv_timeout(Duration::from_secs(1)) + .unwrap(); + crate::voting_service::VotingService::handle_vote(&cluster_info, &poh_recorder, vote_info); + let mut cursor = Cursor::default(); let (_, votes) = cluster_info.get_votes(&mut cursor); assert_eq!(votes.len(), 1); @@ -4709,13 +4719,13 @@ mod tests { &mut tower, &cluster_info, refresh_bank, - &poh_recorder, Tower::last_voted_slot_in_bank(refresh_bank, &my_vote_pubkey).unwrap(), &my_vote_pubkey, &my_vote_keypair, &mut voted_signatures, has_new_vote_been_rooted, &mut last_vote_refresh_time, + &voting_sender, ); // No new votes have been submitted to gossip @@ -4732,7 +4742,6 @@ mod tests { ReplayStage::push_vote( &cluster_info, &bank1, - &poh_recorder, &my_vote_pubkey, &my_vote_keypair, &mut tower, @@ -4740,7 +4749,12 @@ mod tests { &mut voted_signatures, has_new_vote_been_rooted, &mut ReplayTiming::default(), + &voting_sender, ); + let vote_info = voting_receiver + .recv_timeout(Duration::from_secs(1)) + .unwrap(); + crate::voting_service::VotingService::handle_vote(&cluster_info, &poh_recorder, vote_info); let (_, votes) = cluster_info.get_votes(&mut cursor); assert_eq!(votes.len(), 1); let vote_tx = &votes[0]; @@ -4754,14 +4768,15 @@ mod tests { &mut tower, &cluster_info, &bank2, - &poh_recorder, Tower::last_voted_slot_in_bank(&bank2, &my_vote_pubkey).unwrap(), &my_vote_pubkey, &my_vote_keypair, &mut voted_signatures, has_new_vote_been_rooted, &mut last_vote_refresh_time, + &voting_sender, ); + // No new votes have been submitted to gossip let (_, votes) = cluster_info.get_votes(&mut cursor); assert!(votes.is_empty()); @@ -4790,14 +4805,19 @@ mod tests { &mut tower, &cluster_info, &expired_bank, - &poh_recorder, Tower::last_voted_slot_in_bank(&expired_bank, &my_vote_pubkey).unwrap(), &my_vote_pubkey, &my_vote_keypair, &mut voted_signatures, has_new_vote_been_rooted, &mut last_vote_refresh_time, + &voting_sender, ); + let vote_info = voting_receiver + .recv_timeout(Duration::from_secs(1)) + .unwrap(); + crate::voting_service::VotingService::handle_vote(&cluster_info, &poh_recorder, vote_info); + assert!(last_vote_refresh_time.last_refresh_time > clone_refresh_time); let (_, votes) = cluster_info.get_votes(&mut cursor); assert_eq!(votes.len(), 1); @@ -4846,14 +4866,15 @@ mod tests { &mut tower, &cluster_info, &expired_bank_sibling, - &poh_recorder, Tower::last_voted_slot_in_bank(&expired_bank_sibling, &my_vote_pubkey).unwrap(), &my_vote_pubkey, &my_vote_keypair, &mut voted_signatures, has_new_vote_been_rooted, &mut last_vote_refresh_time, + &voting_sender, ); + let (_, votes) = cluster_info.get_votes(&mut cursor); assert!(votes.is_empty()); assert_eq!( diff --git a/core/src/tvu.rs b/core/src/tvu.rs index 7b058edcc1..ecdf7104e7 100644 --- a/core/src/tvu.rs +++ b/core/src/tvu.rs @@ -20,6 +20,7 @@ use crate::{ sigverify_shreds::ShredSigVerifier, sigverify_stage::SigVerifyStage, snapshot_packager_service::PendingSnapshotPackage, + voting_service::VotingService, }; use crossbeam_channel::unbounded; use solana_gossip::cluster_info::ClusterInfo; @@ -66,6 +67,7 @@ pub struct Tvu { ledger_cleanup_service: Option, accounts_background_service: AccountsBackgroundService, accounts_hash_verifier: AccountsHashVerifier, + voting_service: VotingService, } pub struct Sockets { @@ -276,6 +278,10 @@ impl Tvu { wait_for_vote_to_start_leader: tvu_config.wait_for_vote_to_start_leader, }; + let (voting_sender, voting_receiver) = channel(); + let voting_service = + VotingService::new(voting_receiver, cluster_info.clone(), poh_recorder.clone()); + let replay_stage = ReplayStage::new( replay_stage_config, blockstore.clone(), @@ -293,6 +299,7 @@ impl Tvu { gossip_confirmed_slots_receiver, gossip_verified_vote_hash_receiver, cluster_slots_update_sender, + voting_sender, ); let ledger_cleanup_service = tvu_config.max_ledger_shreds.map(|max_ledger_shreds| { @@ -323,6 +330,7 @@ impl Tvu { ledger_cleanup_service, accounts_background_service, accounts_hash_verifier, + voting_service, } } @@ -336,6 +344,7 @@ impl Tvu { self.accounts_background_service.join()?; self.replay_stage.join()?; self.accounts_hash_verifier.join()?; + self.voting_service.join()?; Ok(()) } } diff --git a/core/src/voting_service.rs b/core/src/voting_service.rs new file mode 100644 index 0000000000..4dcf8bf59f --- /dev/null +++ b/core/src/voting_service.rs @@ -0,0 +1,79 @@ +use solana_gossip::cluster_info::ClusterInfo; +use solana_poh::poh_recorder::PohRecorder; +use solana_sdk::{clock::Slot, transaction::Transaction}; +use std::{ + sync::{mpsc::Receiver, Arc, Mutex}, + thread::{self, Builder, JoinHandle}, +}; + +pub enum VoteOp { + PushVote { + tx: Transaction, + tower_slots: Vec, + }, + RefreshVote { + tx: Transaction, + last_voted_slot: Slot, + }, +} + +impl VoteOp { + fn tx(&self) -> &Transaction { + match self { + VoteOp::PushVote { tx, tower_slots: _ } => tx, + VoteOp::RefreshVote { + tx, + last_voted_slot: _, + } => tx, + } + } +} + +pub struct VotingService { + thread_hdl: JoinHandle<()>, +} + +impl VotingService { + pub fn new( + vote_receiver: Receiver, + cluster_info: Arc, + poh_recorder: Arc>, + ) -> Self { + let thread_hdl = Builder::new() + .name("sol-vote-service".to_string()) + .spawn(move || { + for vote_op in vote_receiver.iter() { + Self::handle_vote(&cluster_info, &poh_recorder, vote_op); + } + }) + .unwrap(); + Self { thread_hdl } + } + + pub fn handle_vote( + cluster_info: &ClusterInfo, + poh_recorder: &Mutex, + vote_op: VoteOp, + ) { + let _ = cluster_info.send_vote( + vote_op.tx(), + crate::banking_stage::next_leader_tpu(cluster_info, poh_recorder), + ); + + match vote_op { + VoteOp::PushVote { tx, tower_slots } => { + cluster_info.push_vote(&tower_slots, tx); + } + VoteOp::RefreshVote { + tx, + last_voted_slot, + } => { + cluster_info.refresh_vote(tx, last_voted_slot); + } + } + } + + pub fn join(self) -> thread::Result<()> { + self.thread_hdl.join() + } +}