blockworks-foundation
/
solana
mirror of https://github.com/blockworks-foundation/solana.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

removes require-stake-for-gossip feature (#19476) 

The feature is already activated on all clusters.
This commit is contained in:
behzad nouri 2021-08-27 21:17:15 +00:00 committed by GitHub
parent 4305d4b7b1
commit 6909a79b6f
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
3 changed files with 18 additions and 68 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

63
gossip/src/cluster_info.rs
View File

@ -53,7 +53,7 @@ use {
solana_runtime::bank_forks::BankForks, solana_runtime::bank_forks::BankForks,
solana_sdk::{ solana_sdk::{
clock::{Slot, DEFAULT_MS_PER_SLOT, DEFAULT_SLOTS_PER_EPOCH}, clock::{Slot, DEFAULT_MS_PER_SLOT, DEFAULT_SLOTS_PER_EPOCH},
feature_set::{self, FeatureSet}, feature_set::FeatureSet,
hash::Hash, hash::Hash,
pubkey::Pubkey, pubkey::Pubkey,
sanitize::{Sanitize, SanitizeError}, sanitize::{Sanitize, SanitizeError},
@ -1439,18 +1439,14 @@ impl ClusterInfo {
let _ = gossip_crds.insert(entry, now); let _ = gossip_crds.insert(entry, now);
} }
} }
fn new_push_requests( fn new_push_requests(&self, stakes: &HashMap<Pubkey, u64>) -> Vec<(SocketAddr, Protocol)> {
&self,
stakes: &HashMap<Pubkey, u64>,
require_stake_for_gossip: bool,
) -> Vec<(SocketAddr, Protocol)> {
let self_id = self.id(); let self_id = self.id();
let mut push_messages = { let mut push_messages = {
let _st = ScopedTimer::from(&self.stats.new_push_requests); let _st = ScopedTimer::from(&self.stats.new_push_requests);
self.gossip self.gossip
.new_push_messages(self.drain_push_queue(), timestamp()) .new_push_messages(self.drain_push_queue(), timestamp())
}; };
if require_stake_for_gossip { if self.require_stake_for_gossip(stakes) {
push_messages.retain(|_, data| { push_messages.retain(|_, data| {
retain_staked(data, stakes); retain_staked(data, stakes);
!data.is_empty() !data.is_empty()
@ -1487,14 +1483,13 @@ impl ClusterInfo {
gossip_validators: Option<&HashSet<Pubkey>>, gossip_validators: Option<&HashSet<Pubkey>>,
stakes: &HashMap<Pubkey, u64>, stakes: &HashMap<Pubkey, u64>,
generate_pull_requests: bool, generate_pull_requests: bool,
require_stake_for_gossip: bool,
) -> Vec<(SocketAddr, Protocol)> { ) -> Vec<(SocketAddr, Protocol)> {
self.trim_crds_table(CRDS_UNIQUE_PUBKEY_CAPACITY, stakes); self.trim_crds_table(CRDS_UNIQUE_PUBKEY_CAPACITY, stakes);
// This will flush local pending push messages before generating // This will flush local pending push messages before generating
// pull-request bloom filters, preventing pull responses to return the // pull-request bloom filters, preventing pull responses to return the
// same values back to the node itself. Note that packets will arrive // same values back to the node itself. Note that packets will arrive
// and are processed out of order. // and are processed out of order.
let mut out: Vec<_> = self.new_push_requests(stakes, require_stake_for_gossip); let mut out: Vec<_> = self.new_push_requests(stakes);
self.stats self.stats
.packets_sent_push_messages_count .packets_sent_push_messages_count
.add_relaxed(out.len() as u64); .add_relaxed(out.len() as u64);
@ -1522,14 +1517,12 @@ impl ClusterInfo {
stakes: &HashMap<Pubkey, u64>, stakes: &HashMap<Pubkey, u64>,
sender: &PacketSender, sender: &PacketSender,
generate_pull_requests: bool, generate_pull_requests: bool,
require_stake_for_gossip: bool,
) -> Result<(), GossipError> { ) -> Result<(), GossipError> {
let reqs = self.generate_new_gossip_requests( let reqs = self.generate_new_gossip_requests(
thread_pool, thread_pool,
gossip_validators, gossip_validators,
stakes, stakes,
generate_pull_requests, generate_pull_requests,
require_stake_for_gossip,
); );
if !reqs.is_empty() { if !reqs.is_empty() {
let packets = to_packets_with_destination(recycler.clone(), &reqs); let packets = to_packets_with_destination(recycler.clone(), &reqs);
@ -1680,7 +1673,7 @@ impl ClusterInfo {
last_contact_info_save = start; last_contact_info_save = start;
} }
let (stakes, feature_set) = match bank_forks { let (stakes, _feature_set) = match bank_forks {
Some(ref bank_forks) => { Some(ref bank_forks) => {
let root_bank = bank_forks.read().unwrap().root_bank(); let root_bank = bank_forks.read().unwrap().root_bank();
( (
@ -1690,8 +1683,6 @@ impl ClusterInfo {
} }
None => (Arc::default(), None), None => (Arc::default(), None),
}; };
let require_stake_for_gossip =
self.require_stake_for_gossip(feature_set.as_deref(), &stakes);
let _ = self.run_gossip( let _ = self.run_gossip(
&thread_pool, &thread_pool,
gossip_validators.as_ref(), gossip_validators.as_ref(),
@ -1699,7 +1690,6 @@ impl ClusterInfo {
&stakes, &stakes,
&sender, &sender,
generate_pull_requests, generate_pull_requests,
require_stake_for_gossip,
); );
if exit.load(Ordering::Relaxed) { if exit.load(Ordering::Relaxed) {
return; return;
@ -1778,7 +1768,6 @@ impl ClusterInfo {
recycler: &PacketsRecycler, recycler: &PacketsRecycler,
stakes: &HashMap<Pubkey, u64>, stakes: &HashMap<Pubkey, u64>,
response_sender: &PacketSender, response_sender: &PacketSender,
require_stake_for_gossip: bool,
) { ) {
let _st = ScopedTimer::from(&self.stats.handle_batch_pull_requests_time); let _st = ScopedTimer::from(&self.stats.handle_batch_pull_requests_time);
if requests.is_empty() { if requests.is_empty() {
@ -1809,13 +1798,7 @@ impl ClusterInfo {
self.stats self.stats
.pull_requests_count .pull_requests_count
.add_relaxed(requests.len() as u64); .add_relaxed(requests.len() as u64);
let response = self.handle_pull_requests( let response = self.handle_pull_requests(thread_pool, recycler, requests, stakes);
thread_pool,
recycler,
requests,
stakes,
require_stake_for_gossip,
);
if !response.is_empty() { if !response.is_empty() {
self.stats self.stats
.packets_sent_pull_responses_count .packets_sent_pull_responses_count
@ -1889,7 +1872,6 @@ impl ClusterInfo {
recycler: &PacketsRecycler, recycler: &PacketsRecycler,
requests: Vec<PullData>, requests: Vec<PullData>,
stakes: &HashMap<Pubkey, u64>, stakes: &HashMap<Pubkey, u64>,
require_stake_for_gossip: bool,
) -> Packets { ) -> Packets {
const DEFAULT_EPOCH_DURATION_MS: u64 = DEFAULT_SLOTS_PER_EPOCH * DEFAULT_MS_PER_SLOT; const DEFAULT_EPOCH_DURATION_MS: u64 = DEFAULT_SLOTS_PER_EPOCH * DEFAULT_MS_PER_SLOT;
let mut time = Measure::start("handle_pull_requests"); let mut time = Measure::start("handle_pull_requests");
@ -1924,7 +1906,7 @@ impl ClusterInfo {
now, now,
) )
}; };
if require_stake_for_gossip { if self.require_stake_for_gossip(stakes) {
for resp in &mut pull_responses { for resp in &mut pull_responses {
retain_staked(resp, stakes); retain_staked(resp, stakes);
} }
@ -2168,7 +2150,6 @@ impl ClusterInfo {
recycler: &PacketsRecycler, recycler: &PacketsRecycler,
stakes: &HashMap<Pubkey, u64>, stakes: &HashMap<Pubkey, u64>,
response_sender: &PacketSender, response_sender: &PacketSender,
require_stake_for_gossip: bool,
) { ) {
let _st = ScopedTimer::from(&self.stats.handle_batch_push_messages_time); let _st = ScopedTimer::from(&self.stats.handle_batch_push_messages_time);
if messages.is_empty() { if messages.is_empty() {
@ -2245,7 +2226,7 @@ impl ClusterInfo {
self.stats self.stats
.push_response_count .push_response_count
.add_relaxed(packets.packets.len() as u64); .add_relaxed(packets.packets.len() as u64);
let new_push_requests = self.new_push_requests(stakes, require_stake_for_gossip); let new_push_requests = self.new_push_requests(stakes);
inc_new_counter_debug!("cluster_info-push_message-pushes", new_push_requests.len()); inc_new_counter_debug!("cluster_info-push_message-pushes", new_push_requests.len());
for (address, request) in new_push_requests { for (address, request) in new_push_requests {
if ContactInfo::is_valid_address(&address, &self.socket_addr_space) { if ContactInfo::is_valid_address(&address, &self.socket_addr_space) {
@ -2266,22 +2247,8 @@ impl ClusterInfo {
let _ = response_sender.send(packets); let _ = response_sender.send(packets);
} }
fn require_stake_for_gossip( fn require_stake_for_gossip(&self, stakes: &HashMap<Pubkey, u64>) -> bool {
&self, if stakes.len() < MIN_NUM_STAKED_NODES {
feature_set: Option<&FeatureSet>,
stakes: &HashMap<Pubkey, u64>,
) -> bool {
match feature_set {
None => {
self.stats
.require_stake_for_gossip_unknown_feature_set
.add_relaxed(1);
false
}
Some(feature_set) => {
if !feature_set.is_active(&feature_set::require_stake_for_gossip::id()) {
false
} else if stakes.len() < MIN_NUM_STAKED_NODES {
self.stats self.stats
.require_stake_for_gossip_unknown_stakes .require_stake_for_gossip_unknown_stakes
.add_relaxed(1); .add_relaxed(1);
@ -2290,8 +2257,6 @@ impl ClusterInfo {
true true
} }
} }
}
}
fn process_packets( fn process_packets(
&self, &self,
@ -2300,7 +2265,7 @@ impl ClusterInfo {
recycler: &PacketsRecycler, recycler: &PacketsRecycler,
response_sender: &PacketSender, response_sender: &PacketSender,
stakes: &HashMap<Pubkey, u64>, stakes: &HashMap<Pubkey, u64>,
feature_set: Option<&FeatureSet>, _feature_set: Option<&FeatureSet>,
epoch_duration: Duration, epoch_duration: Duration,
should_check_duplicate_instance: bool, should_check_duplicate_instance: bool,
) -> Result<(), GossipError> { ) -> Result<(), GossipError> {
@ -2378,8 +2343,7 @@ impl ClusterInfo {
self.stats self.stats
.packets_received_prune_messages_count .packets_received_prune_messages_count
.add_relaxed(prune_messages.len() as u64); .add_relaxed(prune_messages.len() as u64);
let require_stake_for_gossip = self.require_stake_for_gossip(feature_set, stakes); if self.require_stake_for_gossip(stakes) {
if require_stake_for_gossip {
for (_, data) in &mut pull_responses { for (_, data) in &mut pull_responses {
retain_staked(data, stakes); retain_staked(data, stakes);
} }
@ -2397,7 +2361,6 @@ impl ClusterInfo {
recycler, recycler,
stakes, stakes,
response_sender, response_sender,
require_stake_for_gossip,
); );
self.handle_batch_pull_responses(pull_responses, thread_pool, stakes, epoch_duration); self.handle_batch_pull_responses(pull_responses, thread_pool, stakes, epoch_duration);
self.trim_crds_table(CRDS_UNIQUE_PUBKEY_CAPACITY, stakes); self.trim_crds_table(CRDS_UNIQUE_PUBKEY_CAPACITY, stakes);
@ -2408,7 +2371,6 @@ impl ClusterInfo {
recycler, recycler,
stakes, stakes,
response_sender, response_sender,
require_stake_for_gossip,
); );
Ok(()) Ok(())
} }
@ -3320,7 +3282,6 @@ mod tests {
None, // gossip_validators None, // gossip_validators
&HashMap::new(), // stakes &HashMap::new(), // stakes
true, // generate_pull_requests true, // generate_pull_requests
false, // require_stake_for_gossip
); );
//assert none of the addrs are invalid. //assert none of the addrs are invalid.
reqs.iter().all(|(addr, _)| { reqs.iter().all(|(addr, _)| {

6
gossip/src/cluster_info_metrics.rs
View File

@ -143,7 +143,6 @@ pub(crate) struct GossipStats {
pub(crate) push_response_count: Counter, pub(crate) push_response_count: Counter,
pub(crate) push_vote_read: Counter, pub(crate) push_vote_read: Counter,
pub(crate) repair_peers: Counter, pub(crate) repair_peers: Counter,
pub(crate) require_stake_for_gossip_unknown_feature_set: Counter,
pub(crate) require_stake_for_gossip_unknown_stakes: Counter, pub(crate) require_stake_for_gossip_unknown_stakes: Counter,
pub(crate) skip_pull_response_shred_version: Counter, pub(crate) skip_pull_response_shred_version: Counter,
pub(crate) skip_pull_shred_version: Counter, pub(crate) skip_pull_shred_version: Counter,
@ -422,11 +421,6 @@ pub(crate) fn submit_gossip_stats(
stats.packets_sent_push_messages_count.clear(), stats.packets_sent_push_messages_count.clear(),
i64 i64
), ),
(
"require_stake_for_gossip_unknown_feature_set",
stats.require_stake_for_gossip_unknown_feature_set.clear(),
i64
),
( (
"require_stake_for_gossip_unknown_stakes", "require_stake_for_gossip_unknown_stakes",
stats.require_stake_for_gossip_unknown_stakes.clear(), stats.require_stake_for_gossip_unknown_stakes.clear(),

5
sdk/src/feature_set.rs
View File

@ -91,10 +91,6 @@ pub mod check_program_owner {
solana_sdk::declare_id!("5XnbR5Es9YXEARRuP6mdvoxiW3hx5atNNeBmwVd8P3QD"); solana_sdk::declare_id!("5XnbR5Es9YXEARRuP6mdvoxiW3hx5atNNeBmwVd8P3QD");
} }
pub mod require_stake_for_gossip {
solana_sdk::declare_id!("6oNzd5Z3M2L1xo4Q5hoox7CR2DuW7m1ETLWH5jHJthwa");
}
pub mod enforce_aligned_host_addrs { pub mod enforce_aligned_host_addrs {
solana_sdk::declare_id!("6Qob9Z4RwGdf599FDVCqsjuKjR8ZFR3oVs2ByRLWBsua"); solana_sdk::declare_id!("6Qob9Z4RwGdf599FDVCqsjuKjR8ZFR3oVs2ByRLWBsua");
} }
@ -221,7 +217,6 @@ lazy_static! {
(warp_timestamp_again::id(), "warp timestamp again, adjust bounding to 25% fast 80% slow #15204"), (warp_timestamp_again::id(), "warp timestamp again, adjust bounding to 25% fast 80% slow #15204"),
(check_init_vote_data::id(), "check initialized Vote data"), (check_init_vote_data::id(), "check initialized Vote data"),
(check_program_owner::id(), "limit programs to operating on accounts owned by itself"), (check_program_owner::id(), "limit programs to operating on accounts owned by itself"),
(require_stake_for_gossip::id(), "require stakes for propagating crds values through gossip #15561"),
(enforce_aligned_host_addrs::id(), "enforce aligned host addresses"), (enforce_aligned_host_addrs::id(), "enforce aligned host addresses"),
(stake_program_v4::id(), "solana_stake_program v4"), (stake_program_v4::id(), "solana_stake_program v4"),
(memory_ops_syscalls::id(), "add syscalls for memory operations"), (memory_ops_syscalls::id(), "add syscalls for memory operations"),