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

Pass Arc<AtomicBool> by value, not by reference. (#31916) 

`Arc` is already a reference internally, so it does not seem to be
beneficial to pass a reference to it.  Just adds an extra layer of
indirection.

Functions that need to be able to increment `Arc` reference count need
to take `Arc<AtomicBool>`, but those that just want to read the
`AtomicBool` value can accept `&AtomicBool`, making them a bit more
generic.

This change focuses specifically on `Arc<AtomicBool>`.  There are other
uses of `&Arc<T>` in the code base that could be converted in a similar
manner.  But it would make the change even larger.
This commit is contained in:
Illia Bobyr 2023-06-01 17:25:48 -07:00 committed by GitHub
parent 2b04f28c7b
commit 4353ac6797
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
41 changed files with 181 additions and 195 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
bench-tps/src/bench.rs
View File

@ -248,7 +248,7 @@ where
fn create_sampler_thread<T>(
client: &Arc<T>,
exit_signal: &Arc<AtomicBool>,
exit_signal: Arc<AtomicBool>,
sample_period: u64,
maxes: &Arc<RwLock<Vec<(String, SampleStats)>>>,
) -> JoinHandle<()>
@ -256,13 +256,12 @@ where
T: 'static + BenchTpsClient + Send + Sync + ?Sized,
{
info!("Sampling TPS every {} second...", sample_period);
let exit_signal = exit_signal.clone();
let maxes = maxes.clone();
let client = client.clone();
Builder::new()
.name("solana-client-sample".to_string())
.spawn(move || {
sample_txs(&exit_signal, &maxes, sample_period, &client);
sample_txs(exit_signal, &maxes, sample_period, &client);
})
.unwrap()
}
@ -325,7 +324,7 @@ fn create_sender_threads<T>(
thread_batch_sleep_ms: usize,
total_tx_sent_count: &Arc<AtomicUsize>,
threads: usize,
exit_signal: &Arc<AtomicBool>,
exit_signal: Arc<AtomicBool>,
shared_tx_active_thread_count: &Arc<AtomicIsize>,
) -> Vec<JoinHandle<()>>
where
@ -407,7 +406,7 @@ where
// collect the max transaction rate and total tx count seen
let maxes = Arc::new(RwLock::new(Vec::new()));
let sample_period = 1; // in seconds
let sample_thread = create_sampler_thread(&client, &exit_signal, sample_period, &maxes);
let sample_thread = create_sampler_thread(&client, exit_signal.clone(), sample_period, &maxes);
let shared_txs: SharedTransactions = Arc::new(RwLock::new(VecDeque::new()));
@ -439,7 +438,7 @@ where
thread_batch_sleep_ms,
&total_tx_sent_count,
threads,
&exit_signal,
exit_signal.clone(),
&shared_tx_active_thread_count,
);
@ -786,7 +785,7 @@ fn get_new_latest_blockhash<T: BenchTpsClient + ?Sized>(
}
fn poll_blockhash<T: BenchTpsClient + ?Sized>(
exit_signal: &Arc<AtomicBool>,
exit_signal: &AtomicBool,
blockhash: &Arc<RwLock<Hash>>,
client: &Arc<T>,
id: &Pubkey,
@ -836,7 +835,7 @@ fn poll_blockhash<T: BenchTpsClient + ?Sized>(
}
fn do_tx_transfers<T: BenchTpsClient + ?Sized>(
exit_signal: &Arc<AtomicBool>,
exit_signal: &AtomicBool,
shared_txs: &SharedTransactions,
shared_tx_thread_count: &Arc<AtomicIsize>,
total_tx_sent_count: &Arc<AtomicUsize>,

2
bench-tps/src/perf_utils.rs
View File

@ -23,7 +23,7 @@ pub struct SampleStats {
}
pub fn sample_txs<T>(
exit_signal: &Arc<AtomicBool>,
exit_signal: Arc<AtomicBool>,
sample_stats: &Arc<RwLock<Vec<(String, SampleStats)>>>,
sample_period: u64,
client: &Arc<T>,

12
client-test/tests/client.rs
View File

@ -142,7 +142,7 @@ fn test_account_subscription() {
let max_complete_transaction_status_slot = Arc::new(AtomicU64::default());
let max_complete_rewards_slot = Arc::new(AtomicU64::default());
let subscriptions = Arc::new(RpcSubscriptions::new_for_tests(
&exit,
exit.clone(),
max_complete_transaction_status_slot,
max_complete_rewards_slot,
bank_forks.clone(),
@ -261,7 +261,7 @@ fn test_block_subscription() {
let max_complete_rewards_slot = Arc::new(AtomicU64::default());
// setup RpcSubscriptions && PubSubService
let subscriptions = Arc::new(RpcSubscriptions::new_for_tests_with_blockstore(
&exit,
exit.clone(),
max_complete_transaction_status_slot,
max_complete_rewards_slot,
blockstore.clone(),
@ -348,7 +348,7 @@ fn test_program_subscription() {
let max_complete_transaction_status_slot = Arc::new(AtomicU64::default());
let max_complete_rewards_slot = Arc::new(AtomicU64::default());
let subscriptions = Arc::new(RpcSubscriptions::new_for_tests(
&exit,
exit.clone(),
max_complete_transaction_status_slot,
max_complete_rewards_slot,
bank_forks.clone(),
@ -434,7 +434,7 @@ fn test_root_subscription() {
let max_complete_transaction_status_slot = Arc::new(AtomicU64::default());
let max_complete_rewards_slot = Arc::new(AtomicU64::default());
let subscriptions = Arc::new(RpcSubscriptions::new_for_tests(
&exit,
exit.clone(),
max_complete_transaction_status_slot,
max_complete_rewards_slot,
bank_forks.clone(),
@ -485,7 +485,7 @@ fn test_slot_subscription() {
let max_complete_transaction_status_slot = Arc::new(AtomicU64::default());
let max_complete_rewards_slot = Arc::new(AtomicU64::default());
let subscriptions = Arc::new(RpcSubscriptions::new_for_tests(
&exit,
exit.clone(),
max_complete_transaction_status_slot,
max_complete_rewards_slot,
bank_forks,
@ -561,7 +561,7 @@ async fn test_slot_subscription_async() {
let max_complete_transaction_status_slot = Arc::new(AtomicU64::default());
let max_complete_rewards_slot = Arc::new(AtomicU64::default());
let subscriptions = Arc::new(RpcSubscriptions::new_for_tests(
&exit,
exit.clone(),
max_complete_transaction_status_slot,
max_complete_rewards_slot,
bank_forks,

5
client/src/transaction_executor.rs
View File

@ -51,7 +51,7 @@ impl TransactionExecutor {
let sigs = Arc::new(RwLock::new(Vec::new()));
let cleared = Arc::new(RwLock::new(Vec::new()));
let exit = Arc::new(AtomicBool::new(false));
let sig_clear_t = Self::start_sig_clear_thread(&exit, &sigs, &cleared, &client);
let sig_clear_t = Self::start_sig_clear_thread(exit.clone(), &sigs, &cleared, &client);
Self {
sigs,
cleared,
@ -96,13 +96,12 @@ impl TransactionExecutor {
}
fn start_sig_clear_thread(
exit: &Arc<AtomicBool>,
exit: Arc<AtomicBool>,
sigs: &Arc<RwLock<PendingQueue>>,
cleared: &Arc<RwLock<Vec<u64>>>,
client: &Arc<RpcClient>,
) -> JoinHandle<()> {
let sigs = sigs.clone();
let exit = exit.clone();
let cleared = cleared.clone();
let client = client.clone();
Builder::new()

4
core/src/banking_stage/consumer.rs
View File

@ -1611,7 +1611,7 @@ mod tests {
None,
blockstore.clone(),
false,
&Arc::new(AtomicBool::new(false)),
Arc::new(AtomicBool::new(false)),
);
let (replay_vote_sender, _replay_vote_receiver) = unbounded();
@ -1749,7 +1749,7 @@ mod tests {
None,
blockstore.clone(),
false,
&Arc::new(AtomicBool::new(false)),
Arc::new(AtomicBool::new(false)),
);
let (replay_vote_sender, _replay_vote_receiver) = unbounded();

3
core/src/cache_block_meta_service.rs
View File

@ -26,9 +26,8 @@ impl CacheBlockMetaService {
pub fn new(
cache_block_meta_receiver: CacheBlockMetaReceiver,
blockstore: Arc<Blockstore>,
exit: &Arc<AtomicBool>,
exit: Arc<AtomicBool>,
) -> Self {
let exit = exit.clone();
let thread_hdl = Builder::new()
.name("solCacheBlkTime".to_string())
.spawn(move || loop {

30
core/src/cluster_info_vote_listener.rs
View File

@ -264,18 +264,20 @@ impl ClusterInfoVoteListener {
})
.unwrap()
};
let exit_ = exit.clone();
let bank_send_thread = Builder::new()
.name("solCiBankSend".to_string())
.spawn(move || {
let _ = Self::bank_send_loop(
exit_,
verified_vote_label_packets_receiver,
poh_recorder,
&verified_packets_sender,
);
})
.unwrap();
let bank_send_thread = {
let exit = exit.clone();
Builder::new()
.name("solCiBankSend".to_string())
.spawn(move || {
let _ = Self::bank_send_loop(
exit,
verified_vote_label_packets_receiver,
poh_recorder,
&verified_packets_sender,
);
})
.unwrap()
};
let send_thread = Builder::new()
.name("solCiProcVotes".to_string())
@ -1447,7 +1449,7 @@ mod tests {
let max_complete_transaction_status_slot = Arc::new(AtomicU64::default());
let max_complete_rewards_slot = Arc::new(AtomicU64::default());
let subscriptions = Arc::new(RpcSubscriptions::new_for_tests(
&exit,
exit,
max_complete_transaction_status_slot,
max_complete_rewards_slot,
bank_forks,
@ -1563,7 +1565,7 @@ mod tests {
let max_complete_transaction_status_slot = Arc::new(AtomicU64::default());
let max_complete_rewards_slot = Arc::new(AtomicU64::default());
let subscriptions = Arc::new(RpcSubscriptions::new_for_tests(
&exit,
exit,
max_complete_transaction_status_slot,
max_complete_rewards_slot,
bank_forks,

9
core/src/commitment_service.rs
View File

@ -56,7 +56,7 @@ pub struct AggregateCommitmentService {
impl AggregateCommitmentService {
pub fn new(
exit: &Arc<AtomicBool>,
exit: Arc<AtomicBool>,
block_commitment_cache: Arc<RwLock<BlockCommitmentCache>>,
subscriptions: Arc<RpcSubscriptions>,
) -> (Sender<CommitmentAggregationData>, Self) {
@ -64,19 +64,18 @@ impl AggregateCommitmentService {
Sender<CommitmentAggregationData>,
Receiver<CommitmentAggregationData>,
) = unbounded();
let exit_ = exit.clone();
(
sender,
Self {
t_commitment: Builder::new()
.name("solAggCommitSvc".to_string())
.spawn(move || loop {
if exit_.load(Ordering::Relaxed) {
if exit.load(Ordering::Relaxed) {
break;
}
if let Err(RecvTimeoutError::Disconnected) =
Self::run(&receiver, &block_commitment_cache, &subscriptions, &exit_)
Self::run(&receiver, &block_commitment_cache, &subscriptions, &exit)
{
break;
}
@ -90,7 +89,7 @@ impl AggregateCommitmentService {
receiver: &Receiver<CommitmentAggregationData>,
block_commitment_cache: &RwLock<BlockCommitmentCache>,
subscriptions: &Arc<RpcSubscriptions>,
exit: &Arc<AtomicBool>,
exit: &AtomicBool,
) -> Result<(), RecvTimeoutError> {
loop {
if exit.load(Ordering::Relaxed) {

3
core/src/completed_data_sets_service.rs
View File

@ -32,10 +32,9 @@ impl CompletedDataSetsService {
completed_sets_receiver: CompletedDataSetsReceiver,
blockstore: Arc<Blockstore>,
rpc_subscriptions: Arc<RpcSubscriptions>,
exit: &Arc<AtomicBool>,
exit: Arc<AtomicBool>,
max_slots: Arc<MaxSlots>,
) -> Self {
let exit = exit.clone();
let thread_hdl = Builder::new()
.name("solComplDataSet".to_string())
.spawn(move || loop {

7
core/src/fetch_stage.rs
View File

@ -34,7 +34,7 @@ impl FetchStage {
sockets: Vec<UdpSocket>,
tpu_forwards_sockets: Vec<UdpSocket>,
tpu_vote_sockets: Vec<UdpSocket>,
exit: &Arc<AtomicBool>,
exit: Arc<AtomicBool>,
poh_recorder: &Arc<RwLock<PohRecorder>>,
coalesce: Duration,
) -> (Self, PacketBatchReceiver, PacketBatchReceiver) {
@ -66,7 +66,7 @@ impl FetchStage {
sockets: Vec<UdpSocket>,
tpu_forwards_sockets: Vec<UdpSocket>,
tpu_vote_sockets: Vec<UdpSocket>,
exit: &Arc<AtomicBool>,
exit: Arc<AtomicBool>,
sender: &PacketBatchSender,
vote_sender: &PacketBatchSender,
forward_sender: &PacketBatchSender,
@ -142,7 +142,7 @@ impl FetchStage {
tpu_sockets: Vec<Arc<UdpSocket>>,
tpu_forwards_sockets: Vec<Arc<UdpSocket>>,
tpu_vote_sockets: Vec<Arc<UdpSocket>>,
exit: &Arc<AtomicBool>,
exit: Arc<AtomicBool>,
sender: &PacketBatchSender,
vote_sender: &PacketBatchSender,
forward_sender: &PacketBatchSender,
@ -234,7 +234,6 @@ impl FetchStage {
})
.unwrap();
let exit = exit.clone();
let metrics_thread_hdl = Builder::new()
.name("solFetchStgMetr".to_string())
.spawn(move || loop {

3
core/src/ledger_cleanup_service.rs
View File

@ -49,9 +49,8 @@ impl LedgerCleanupService {
new_root_receiver: Receiver<Slot>,
blockstore: Arc<Blockstore>,
max_ledger_shreds: u64,
exit: &Arc<AtomicBool>,
exit: Arc<AtomicBool>,
) -> Self {
let exit = exit.clone();
let mut last_purge_slot = 0;
info!(

5
core/src/ledger_metric_report_service.rs
View File

@ -23,12 +23,11 @@ pub struct LedgerMetricReportService {
}
impl LedgerMetricReportService {
pub fn new(blockstore: Arc<Blockstore>, exit: &Arc<AtomicBool>) -> Self {
let exit_signal = exit.clone();
pub fn new(blockstore: Arc<Blockstore>, exit: Arc<AtomicBool>) -> Self {
let t_cf_metric = Builder::new()
.name("solRocksCfMtrcs".to_string())
.spawn(move || loop {
if exit_signal.load(Ordering::Relaxed) {
if exit.load(Ordering::Relaxed) {
break;
}
thread::sleep(Duration::from_millis(

7
core/src/poh_timing_report_service.rs
View File

@ -24,13 +24,12 @@ pub struct PohTimingReportService {
}
impl PohTimingReportService {
pub fn new(receiver: PohTimingReceiver, exit: &Arc<AtomicBool>) -> Self {
let exit_signal = exit.clone();
pub fn new(receiver: PohTimingReceiver, exit: Arc<AtomicBool>) -> Self {
let mut poh_timing_reporter = PohTimingReporter::default();
let t_poh_timing = Builder::new()
.name("solPohTimingRpt".to_string())
.spawn(move || loop {
if exit_signal.load(Ordering::Relaxed) {
if exit.load(Ordering::Relaxed) {
break;
}
if let Ok(SlotPohTimingInfo {
@ -65,7 +64,7 @@ mod test {
let exit = Arc::new(AtomicBool::new(false));
// Create the service
let poh_timing_report_service =
PohTimingReportService::new(poh_timing_point_receiver, &exit);
PohTimingReportService::new(poh_timing_point_receiver, exit.clone());
// Send SlotPohTimingPoint
let _ = poh_timing_point_sender.send(SlotPohTimingInfo::new_slot_start_poh_time_point(

10
core/src/replay_stage.rs
View File

@ -536,7 +536,7 @@ impl ReplayStage {
trace!("replay stage");
// Start the replay stage loop
let (lockouts_sender, commitment_service) = AggregateCommitmentService::new(
&exit,
exit.clone(),
block_commitment_cache.clone(),
rpc_subscriptions.clone(),
);
@ -3971,7 +3971,7 @@ pub(crate) mod tests {
let max_complete_transaction_status_slot = Arc::new(AtomicU64::default());
let max_complete_rewards_slot = Arc::new(AtomicU64::default());
let rpc_subscriptions = Arc::new(RpcSubscriptions::new_for_tests(
&exit,
exit,
max_complete_transaction_status_slot,
max_complete_rewards_slot,
bank_forks.clone(),
@ -4541,7 +4541,7 @@ pub(crate) mod tests {
let max_complete_transaction_status_slot = Arc::new(AtomicU64::default());
let max_complete_rewards_slot = Arc::new(AtomicU64::default());
let rpc_subscriptions = Arc::new(RpcSubscriptions::new_for_tests(
&exit,
exit,
max_complete_transaction_status_slot,
max_complete_rewards_slot,
bank_forks.clone(),
@ -4614,7 +4614,7 @@ pub(crate) mod tests {
let max_complete_transaction_status_slot = Arc::new(AtomicU64::default());
let max_complete_rewards_slot = Arc::new(AtomicU64::default());
let rpc_subscriptions = Arc::new(RpcSubscriptions::new_for_tests(
&exit,
exit.clone(),
max_complete_transaction_status_slot,
max_complete_rewards_slot,
bank_forks.clone(),
@ -4622,7 +4622,7 @@ pub(crate) mod tests {
OptimisticallyConfirmedBank::locked_from_bank_forks_root(&bank_forks),
));
let (lockouts_sender, _) = AggregateCommitmentService::new(
&exit,
exit,
block_commitment_cache.clone(),
rpc_subscriptions,
);

3
core/src/rewards_recorder_service.rs
View File

@ -32,9 +32,8 @@ impl RewardsRecorderService {
rewards_receiver: RewardsRecorderReceiver,
max_complete_rewards_slot: Arc<AtomicU64>,
blockstore: Arc<Blockstore>,
exit: &Arc<AtomicBool>,
exit: Arc<AtomicBool>,
) -> Self {
let exit = exit.clone();
let thread_hdl = Builder::new()
.name("solRewardsWritr".to_string())
.spawn(move || loop {

3
core/src/sample_performance_service.rs
View File

@ -22,9 +22,8 @@ impl SamplePerformanceService {
pub fn new(
bank_forks: &Arc<RwLock<BankForks>>,
blockstore: &Arc<Blockstore>,
exit: &Arc<AtomicBool>,
exit: Arc<AtomicBool>,
) -> Self {
let exit = exit.clone();
let blockstore = blockstore.clone();
let bank_forks = bank_forks.clone();

8
core/src/shred_fetch_stage.rs
View File

@ -114,7 +114,7 @@ impl ShredFetchStage {
#[allow(clippy::too_many_arguments)]
fn packet_modifier(
sockets: Vec<Arc<UdpSocket>>,
exit: &Arc<AtomicBool>,
exit: Arc<AtomicBool>,
sender: Sender<PacketBatch>,
recycler: PacketBatchRecycler,
bank_forks: Arc<RwLock<BankForks>>,
@ -170,13 +170,13 @@ impl ShredFetchStage {
bank_forks: Arc<RwLock<BankForks>>,
cluster_info: Arc<ClusterInfo>,
turbine_disabled: Arc<AtomicBool>,
exit: &Arc<AtomicBool>,
exit: Arc<AtomicBool>,
) -> Self {
let recycler = PacketBatchRecycler::warmed(100, 1024);
let (mut tvu_threads, tvu_filter) = Self::packet_modifier(
sockets,
exit,
exit.clone(),
sender.clone(),
recycler.clone(),
bank_forks.clone(),
@ -189,7 +189,7 @@ impl ShredFetchStage {
let (tvu_forwards_threads, fwd_thread_hdl) = Self::packet_modifier(
forward_sockets,
exit,
exit.clone(),
sender.clone(),
recycler.clone(),
bank_forks.clone(),

3
core/src/stats_reporter_service.rs
View File

@ -18,9 +18,8 @@ pub struct StatsReporterService {
impl StatsReporterService {
pub fn new(
reporting_receiver: Receiver<Box<dyn FnOnce() + Send>>,
exit: &Arc<AtomicBool>,
exit: Arc<AtomicBool>,
) -> Self {
let exit = exit.clone();
let thread_hdl = Builder::new()
.name("solStatsReport".to_owned())
.spawn(move || loop {

6
core/src/tpu.rs
View File

@ -87,7 +87,7 @@ impl Tpu {
_entry_notification_sender: Option<EntryNotifierSender>,
blockstore: &Arc<Blockstore>,
broadcast_type: &BroadcastStageType,
exit: &Arc<AtomicBool>,
exit: Arc<AtomicBool>,
shred_version: u16,
vote_tracker: Arc<VoteTracker>,
bank_forks: Arc<RwLock<BankForks>>,
@ -125,7 +125,7 @@ impl Tpu {
transactions_sockets,
tpu_forwards_sockets,
tpu_vote_sockets,
exit,
exit.clone(),
&packet_sender,
&vote_packet_sender,
&forwarded_packet_sender,
@ -234,7 +234,7 @@ impl Tpu {
cluster_info.clone(),
entry_receiver,
retransmit_slots_receiver,
exit.clone(),
exit,
blockstore.clone(),
bank_forks,
shred_version,

12
core/src/tvu.rs
View File

@ -114,7 +114,7 @@ impl Tvu {
maybe_process_block_store: Option<ProcessBlockStore>,
tower_storage: Arc<dyn TowerStorage>,
leader_schedule_cache: &Arc<LeaderScheduleCache>,
exit: &Arc<AtomicBool>,
exit: Arc<AtomicBool>,
block_commitment_cache: Arc<RwLock<BlockCommitmentCache>>,
turbine_disabled: Arc<AtomicBool>,
transaction_status_sender: Option<TransactionStatusSender>,
@ -163,7 +163,7 @@ impl Tvu {
bank_forks.clone(),
cluster_info.clone(),
turbine_disabled,
exit,
exit.clone(),
);
let (verified_sender, verified_receiver) = unbounded();
@ -313,12 +313,12 @@ impl Tvu {
ledger_cleanup_slot_receiver,
blockstore.clone(),
max_ledger_shreds,
exit,
exit.clone(),
)
});
let duplicate_shred_listener = DuplicateShredListener::new(
exit.clone(),
exit,
cluster_info.clone(),
DuplicateShredHandler::new(
blockstore,
@ -448,7 +448,7 @@ pub mod tests {
blockstore,
ledger_signal_receiver,
&Arc::new(RpcSubscriptions::new_for_tests(
&exit,
exit.clone(),
max_complete_transaction_status_slot,
max_complete_rewards_slot,
bank_forks.clone(),
@ -459,7 +459,7 @@ pub mod tests {
None,
Arc::new(crate::tower_storage::FileTowerStorage::default()),
&leader_schedule_cache,
&exit,
exit.clone(),
block_commitment_cache,
Arc::<AtomicBool>::default(),
None,

48
core/src/validator.rs
View File

@ -384,13 +384,12 @@ struct BlockstoreRootScan {
}
impl BlockstoreRootScan {
fn new(config: &ValidatorConfig, blockstore: &Arc<Blockstore>, exit: &Arc<AtomicBool>) -> Self {
fn new(config: &ValidatorConfig, blockstore: &Arc<Blockstore>, exit: Arc<AtomicBool>) -> Self {
let thread = if config.rpc_addrs.is_some()
&& config.rpc_config.enable_rpc_transaction_history
&& config.rpc_config.rpc_scan_and_fix_roots
{
let blockstore = blockstore.clone();
let exit = exit.clone();
Some(
Builder::new()
.name("solBStoreRtScan".to_string())
@ -616,7 +615,7 @@ impl Validator {
);
let system_monitor_service = Some(SystemMonitorService::new(
Arc::clone(&exit),
exit.clone(),
SystemMonitorStatsReportConfig {
report_os_memory_stats: !config.no_os_memory_stats_reporting,
report_os_network_stats: !config.no_os_network_stats_reporting,
@ -627,7 +626,7 @@ impl Validator {
let (poh_timing_point_sender, poh_timing_point_receiver) = unbounded();
let poh_timing_report_service =
PohTimingReportService::new(poh_timing_point_receiver, &exit);
PohTimingReportService::new(poh_timing_point_receiver, exit.clone());
let (
genesis_config,
@ -655,7 +654,7 @@ impl Validator {
) = load_blockstore(
config,
ledger_path,
&exit,
exit.clone(),
&start_progress,
accounts_update_notifier,
transaction_notifier,
@ -811,7 +810,7 @@ impl Validator {
Some(SamplePerformanceService::new(
&bank_forks,
&blockstore,
&exit,
exit.clone(),
))
} else {
None
@ -830,7 +829,7 @@ impl Validator {
OptimisticallyConfirmedBank::locked_from_bank_forks_root(&bank_forks);
let rpc_subscriptions = Arc::new(RpcSubscriptions::new_with_config(
&exit,
exit.clone(),
max_complete_transaction_status_slot.clone(),
max_complete_rewards_slot.clone(),
blockstore.clone(),
@ -848,7 +847,7 @@ impl Validator {
completed_data_sets_receiver,
blockstore.clone(),
rpc_subscriptions.clone(),
&exit,
exit.clone(),
max_slots.clone(),
);
@ -972,7 +971,7 @@ impl Validator {
},
Some(OptimisticallyConfirmedBankTracker::new(
bank_notification_receiver,
&exit,
exit.clone(),
bank_forks.clone(),
optimistically_confirmed_bank,
rpc_subscriptions.clone(),
@ -1010,7 +1009,8 @@ impl Validator {
let (stats_reporter_sender, stats_reporter_receiver) = unbounded();
let stats_reporter_service = StatsReporterService::new(stats_reporter_receiver, &exit);
let stats_reporter_service =
StatsReporterService::new(stats_reporter_receiver, exit.clone());
let gossip_service = GossipService::new(
&cluster_info,
@ -1019,7 +1019,7 @@ impl Validator {
config.gossip_validators.clone(),
should_check_duplicate_instance,
Some(stats_reporter_sender.clone()),
&exit,
exit.clone(),
);
let serve_repair = ServeRepair::new(
cluster_info.clone(),
@ -1055,7 +1055,7 @@ impl Validator {
};
let ledger_metric_report_service =
LedgerMetricReportService::new(blockstore.clone(), &exit);
LedgerMetricReportService::new(blockstore.clone(), exit.clone());
let wait_for_vote_to_start_leader =
!waited_for_supermajority && !config.no_wait_for_vote_to_start_leader;
@ -1063,7 +1063,7 @@ impl Validator {
let poh_service = PohService::new(
poh_recorder.clone(),
&genesis_config.poh_config,
&exit,
exit.clone(),
bank_forks.read().unwrap().root_bank().ticks_per_slot(),
config.poh_pinned_cpu_core,
config.poh_hashes_per_batch,
@ -1127,7 +1127,7 @@ impl Validator {
Some(process_blockstore),
config.tower_storage.clone(),
&leader_schedule_cache,
&exit,
exit.clone(),
block_commitment_cache,
config.turbine_disabled.clone(),
transaction_status_sender.clone(),
@ -1178,7 +1178,7 @@ impl Validator {
entry_notification_sender,
&blockstore,
&config.broadcast_stage_type,
&exit,
exit,
node.info.shred_version(),
vote_tracker,
bank_forks.clone(),
@ -1527,7 +1527,7 @@ fn blockstore_options_from_config(config: &ValidatorConfig) -> BlockstoreOptions
fn load_blockstore(
config: &ValidatorConfig,
ledger_path: &Path,
exit: &Arc<AtomicBool>,
exit: Arc<AtomicBool>,
start_progress: &Arc<RwLock<ValidatorStartProgress>>,
accounts_update_notifier: Option<AccountsUpdateNotifier>,
transaction_notifier: Option<TransactionNotifierLock>,
@ -1590,7 +1590,7 @@ fn load_blockstore(
let original_blockstore_root = blockstore.last_root();
let blockstore = Arc::new(blockstore);
let blockstore_root_scan = BlockstoreRootScan::new(config, &blockstore, exit);
let blockstore_root_scan = BlockstoreRootScan::new(config, &blockstore, exit.clone());
let halt_at_slot = config
.halt_at_slot
.or_else(|| blockstore.highest_slot().unwrap_or(None));
@ -1616,7 +1616,7 @@ fn load_blockstore(
if enable_rpc_transaction_history || is_plugin_transaction_history_required {
initialize_rpc_transaction_history_services(
blockstore.clone(),
exit,
exit.clone(),
enable_rpc_transaction_history,
config.rpc_config.enable_extended_tx_metadata_storage,
transaction_notifier,
@ -1625,8 +1625,8 @@ fn load_blockstore(
TransactionHistoryServices::default()
};
let entry_notifier_service =
entry_notifier.map(|entry_notifier| EntryNotifierService::new(entry_notifier, exit));
let entry_notifier_service = entry_notifier
.map(|entry_notifier| EntryNotifierService::new(entry_notifier, exit.clone()));
let (bank_forks, mut leader_schedule_cache, starting_snapshot_hashes) =
bank_forks_utils::load_bank_forks(
@ -1643,7 +1643,7 @@ fn load_blockstore(
.as_ref()
.map(|service| service.sender()),
accounts_update_notifier,
exit.clone(),
exit,
);
// Before replay starts, set the callbacks in each of the banks in BankForks so that
@ -2002,7 +2002,7 @@ fn backup_and_clear_blockstore(
fn initialize_rpc_transaction_history_services(
blockstore: Arc<Blockstore>,
exit: &Arc<AtomicBool>,
exit: Arc<AtomicBool>,
enable_rpc_transaction_history: bool,
enable_extended_tx_metadata_storage: bool,
transaction_notifier: Option<TransactionNotifierLock>,
@ -2019,7 +2019,7 @@ fn initialize_rpc_transaction_history_services(
transaction_notifier,
blockstore.clone(),
enable_extended_tx_metadata_storage,
exit,
exit.clone(),
));
let max_complete_rewards_slot = Arc::new(AtomicU64::new(blockstore.max_root()));
@ -2029,7 +2029,7 @@ fn initialize_rpc_transaction_history_services(
rewards_receiver,
max_complete_rewards_slot.clone(),
blockstore.clone(),
exit,
exit.clone(),
));
let (cache_block_meta_sender, cache_block_meta_receiver) = unbounded();

7
core/tests/ledger_cleanup.rs
View File

@ -116,8 +116,7 @@ mod tests {
}
impl CpuStatsUpdater {
pub fn new(exit: &Arc<AtomicBool>) -> Self {
let exit = exit.clone();
pub fn new(exit: Arc<AtomicBool>) -> Self {
let cpu_stats = Arc::new(CpuStats::default());
let cpu_stats_clone = cpu_stats.clone();
@ -370,14 +369,14 @@ mod tests {
receiver,
blockstore.clone(),
max_ledger_shreds,
&exit,
exit.clone(),
))
} else {
None
};
let exit_cpu = Arc::new(AtomicBool::new(false));
let sys = CpuStatsUpdater::new(&exit_cpu);
let sys = CpuStatsUpdater::new(exit_cpu.clone());
let mut shreds = VecDeque::new();

18
gossip/src/gossip_service.rs
View File

@ -39,7 +39,7 @@ impl GossipService {
gossip_validators: Option<HashSet<Pubkey>>,
should_check_duplicate_instance: bool,
stats_reporter_sender: Option<Sender<Box<dyn FnOnce() + Send>>>,
exit: &Arc<AtomicBool>,
exit: Arc<AtomicBool>,
) -> Self {
let (request_sender, request_receiver) = unbounded();
let gossip_socket = Arc::new(gossip_socket);
@ -73,12 +73,10 @@ impl GossipService {
should_check_duplicate_instance,
exit.clone(),
);
let t_gossip = cluster_info.clone().gossip(
bank_forks,
response_sender,
gossip_validators,
exit.clone(),
);
let t_gossip =
cluster_info
.clone()
.gossip(bank_forks, response_sender, gossip_validators, exit);
let t_responder = streamer::responder(
"Gossip",
gossip_socket,
@ -144,7 +142,7 @@ pub fn discover(
let (gossip_service, ip_echo, spy_ref) = make_gossip_node(
keypair,
entrypoint,
&exit,
exit.clone(),
my_gossip_addr,
my_shred_version,
true, // should_check_duplicate_instance,
@ -302,7 +300,7 @@ fn spy(
pub fn make_gossip_node(
keypair: Keypair,
entrypoint: Option<&SocketAddr>,
exit: &Arc<AtomicBool>,
exit: Arc<AtomicBool>,
gossip_addr: Option<&SocketAddr>,
shred_version: u16,
should_check_duplicate_instance: bool,
@ -360,7 +358,7 @@ mod tests {
None,
true, // should_check_duplicate_instance
None,
&exit,
exit.clone(),
);
exit.store(true, Ordering::Relaxed);
d.join().unwrap();

18
gossip/tests/gossip.rs
View File

@ -35,7 +35,7 @@ use {
},
};
fn test_node(exit: &Arc<AtomicBool>) -> (Arc<ClusterInfo>, GossipService, UdpSocket) {
fn test_node(exit: Arc<AtomicBool>) -> (Arc<ClusterInfo>, GossipService, UdpSocket) {
let keypair = Arc::new(Keypair::new());
let mut test_node = Node::new_localhost_with_pubkey(&keypair.pubkey());
let cluster_info = Arc::new(ClusterInfo::new(
@ -62,7 +62,7 @@ fn test_node(exit: &Arc<AtomicBool>) -> (Arc<ClusterInfo>, GossipService, UdpSoc
fn test_node_with_bank(
node_keypair: Arc<Keypair>,
exit: &Arc<AtomicBool>,
exit: Arc<AtomicBool>,
bank_forks: Arc<RwLock<BankForks>>,
) -> (Arc<ClusterInfo>, GossipService, UdpSocket) {
let mut test_node = Node::new_localhost_with_pubkey(&node_keypair.pubkey());
@ -97,7 +97,7 @@ where
F: Fn(&Vec<(Arc<ClusterInfo>, GossipService, UdpSocket)>),
{
let exit = Arc::new(AtomicBool::new(false));
let listen: Vec<_> = (0..num).map(|_| test_node(&exit)).collect();
let listen: Vec<_> = (0..num).map(|_| test_node(exit.clone())).collect();
topo(&listen);
let mut done = true;
for i in 0..(num * 32) {
@ -229,11 +229,11 @@ pub fn cluster_info_retransmit() {
solana_logger::setup();
let exit = Arc::new(AtomicBool::new(false));
trace!("c1:");
let (c1, dr1, tn1) = test_node(&exit);
let (c1, dr1, tn1) = test_node(exit.clone());
trace!("c2:");
let (c2, dr2, tn2) = test_node(&exit);
let (c2, dr2, tn2) = test_node(exit.clone());
trace!("c3:");
let (c3, dr3, tn3) = test_node(&exit);
let (c3, dr3, tn3) = test_node(exit.clone());
let c1_contact_info = c1.my_contact_info();
c2.insert_info(c1_contact_info.clone());
@ -315,7 +315,11 @@ pub fn cluster_info_scale() {
let nodes: Vec<_> = vote_keypairs
.into_iter()
.map(|keypairs| {
test_node_with_bank(Arc::new(keypairs.node_keypair), &exit, bank_forks.clone())
test_node_with_bank(
Arc::new(keypairs.node_keypair),
exit.clone(),
bank_forks.clone(),
)
})
.collect();
let ci0 = nodes[0].0.my_contact_info();

2
ledger-tool/src/ledger_utils.rs
View File

@ -304,7 +304,7 @@ pub fn load_and_process_ledger(
transaction_notifier,
blockstore.clone(),
false,
&exit,
exit.clone(),
);
(
Some(TransactionStatusSender {

3
ledger/src/entry_notifier_service.rs
View File

@ -28,8 +28,7 @@ pub struct EntryNotifierService {
}
impl EntryNotifierService {
pub fn new(entry_notifier: EntryNotifierLock, exit: &Arc<AtomicBool>) -> Self {
let exit = exit.clone();
pub fn new(entry_notifier: EntryNotifierLock, exit: Arc<AtomicBool>) -> Self {
let (entry_notification_sender, entry_notification_receiver) = unbounded();
let thread_hdl = Builder::new()
.name("solEntryNotif".to_string())

2
local-cluster/src/cluster_tests.rs
View File

@ -497,7 +497,7 @@ pub fn start_gossip_voter(
// node later.
node_keypair.insecure_clone(),
Some(gossip_addr),
&exit,
exit.clone(),
None,
0,
false,

2
poh/src/poh_recorder.rs
View File

@ -1066,7 +1066,7 @@ pub fn create_test_recorder(
let poh_service = PohService::new(
poh_recorder.clone(),
&poh_config,
&exit,
exit.clone(),
bank.ticks_per_slot(),
crate::poh_service::DEFAULT_PINNED_CPU_CORE,
crate::poh_service::DEFAULT_HASHES_PER_BATCH,

13
poh/src/poh_service.rs
View File

@ -97,13 +97,12 @@ impl PohService {
pub fn new(
poh_recorder: Arc<RwLock<PohRecorder>>,
poh_config: &PohConfig,
poh_exit: &Arc<AtomicBool>,
poh_exit: Arc<AtomicBool>,
ticks_per_slot: u64,
pinned_cpu_core: usize,
hashes_per_batch: u64,
record_receiver: Receiver<Record>,
) -> Self {
let poh_exit_ = poh_exit.clone();
let poh_config = poh_config.clone();
let tick_producer = Builder::new()
.name("solPohTickProd".to_string())
@ -113,14 +112,14 @@ impl PohService {
Self::low_power_tick_producer(
poh_recorder,
&poh_config,
&poh_exit_,
&poh_exit,
record_receiver,
);
} else {
Self::short_lived_low_power_tick_producer(
poh_recorder,
&poh_config,
&poh_exit_,
&poh_exit,
record_receiver,
);
}
@ -133,7 +132,7 @@ impl PohService {
}
Self::tick_producer(
poh_recorder,
&poh_exit_,
&poh_exit,
ticks_per_slot,
hashes_per_batch,
record_receiver,
@ -143,7 +142,7 @@ impl PohService {
),
);
}
poh_exit_.store(true, Ordering::Relaxed);
poh_exit.store(true, Ordering::Relaxed);
})
.unwrap();
@ -493,7 +492,7 @@ mod tests {
let poh_service = PohService::new(
poh_recorder.clone(),
&poh_config,
&exit,
exit.clone(),
0,
DEFAULT_PINNED_CPU_CORE,
hashes_per_batch,

7
rpc/src/optimistically_confirmed_bank_tracker.rs
View File

@ -87,13 +87,12 @@ pub struct OptimisticallyConfirmedBankTracker {
impl OptimisticallyConfirmedBankTracker {
pub fn new(
receiver: BankNotificationReceiver,
exit: &Arc<AtomicBool>,
exit: Arc<AtomicBool>,
bank_forks: Arc<RwLock<BankForks>>,
optimistically_confirmed_bank: Arc<RwLock<OptimisticallyConfirmedBank>>,
subscriptions: Arc<RpcSubscriptions>,
slot_notification_subscribers: Option<Arc<RwLock<Vec<SlotNotificationSender>>>>,
) -> Self {
let exit_ = exit.clone();
let mut pending_optimistically_confirmed_banks = HashSet::new();
let mut last_notified_confirmed_slot: Slot = 0;
let mut highest_confirmed_slot: Slot = 0;
@ -101,7 +100,7 @@ impl OptimisticallyConfirmedBankTracker {
let thread_hdl = Builder::new()
.name("solOpConfBnkTrk".to_string())
.spawn(move || loop {
if exit_.load(Ordering::Relaxed) {
if exit.load(Ordering::Relaxed) {
break;
}
@ -433,7 +432,7 @@ mod tests {
let max_complete_transaction_status_slot = Arc::new(AtomicU64::default());
let max_complete_rewards_slot = Arc::new(AtomicU64::default());
let subscriptions = Arc::new(RpcSubscriptions::new_for_tests(
&exit,
exit,
max_complete_transaction_status_slot,
max_complete_rewards_slot,
bank_forks.clone(),

21
rpc/src/rpc.rs
View File

@ -382,12 +382,12 @@ impl JsonRpcRequestProcessor {
CommitmentSlots::new_from_slot(bank.slot()),
))),
blockstore,
validator_exit: create_validator_exit(&exit),
validator_exit: create_validator_exit(exit.clone()),
health: Arc::new(RpcHealth::new(
cluster_info.clone(),
None,
0,
exit.clone(),
exit,
Arc::clone(bank.get_startup_verification_complete()),
)),
cluster_info,
@ -4526,10 +4526,9 @@ fn sanitize_transaction(
.map_err(|err| Error::invalid_params(format!("invalid transaction: {err}")))
}
pub fn create_validator_exit(exit: &Arc<AtomicBool>) -> Arc<RwLock<Exit>> {
pub fn create_validator_exit(exit: Arc<AtomicBool>) -> Arc<RwLock<Exit>> {
let mut validator_exit = Exit::default();
let exit_ = exit.clone();
validator_exit.register_exit(Box::new(move || exit_.store(true, Ordering::Relaxed)));
validator_exit.register_exit(Box::new(move || exit.store(true, Ordering::Relaxed)));
Arc::new(RwLock::new(validator_exit))
}
@ -4596,7 +4595,7 @@ pub fn populate_blockstore_for_tests(
None,
blockstore,
false,
&Arc::new(AtomicBool::new(false)),
Arc::new(AtomicBool::new(false)),
);
// Check that process_entries successfully writes can_commit transactions statuses, and
@ -4780,7 +4779,7 @@ pub mod tests {
let leader_pubkey = *bank.collector_id();
let block_commitment_cache = Arc::new(RwLock::new(BlockCommitmentCache::default()));
let exit = Arc::new(AtomicBool::new(false));
let validator_exit = create_validator_exit(&exit);
let validator_exit = create_validator_exit(exit);
let cluster_info = Arc::new(new_test_cluster_info());
let identity = cluster_info.id();
cluster_info.insert_info(ContactInfo::new_with_socketaddr(
@ -6401,7 +6400,7 @@ pub mod tests {
#[test]
fn test_rpc_send_transaction_preflight() {
let exit = Arc::new(AtomicBool::new(false));
let validator_exit = create_validator_exit(&exit);
let validator_exit = create_validator_exit(exit.clone());
let ledger_path = get_tmp_ledger_path!();
let blockstore = Arc::new(Blockstore::open(&ledger_path).unwrap());
let block_commitment_cache = Arc::new(RwLock::new(BlockCommitmentCache::default()));
@ -6672,7 +6671,7 @@ pub mod tests {
#[test]
fn test_rpc_processor_get_block_commitment() {
let exit = Arc::new(AtomicBool::new(false));
let validator_exit = create_validator_exit(&exit);
let validator_exit = create_validator_exit(exit.clone());
let bank_forks = new_bank_forks().0;
let ledger_path = get_tmp_ledger_path!();
let blockstore = Arc::new(Blockstore::open(&ledger_path).unwrap());
@ -8287,7 +8286,7 @@ pub mod tests {
#[test]
fn test_rpc_single_gossip() {
let exit = Arc::new(AtomicBool::new(false));
let validator_exit = create_validator_exit(&exit);
let validator_exit = create_validator_exit(exit.clone());
let ledger_path = get_tmp_ledger_path!();
let blockstore = Arc::new(Blockstore::open(&ledger_path).unwrap());
let block_commitment_cache = Arc::new(RwLock::new(BlockCommitmentCache::default()));
@ -8312,7 +8311,7 @@ pub mod tests {
let max_complete_transaction_status_slot = Arc::new(AtomicU64::default());
let max_complete_rewards_slot = Arc::new(AtomicU64::default());
let subscriptions = Arc::new(RpcSubscriptions::new_for_tests(
&exit,
exit,
max_complete_transaction_status_slot.clone(),
max_complete_rewards_slot.clone(),
bank_forks.clone(),

12
rpc/src/rpc_pubsub.rs
View File

@ -688,7 +688,7 @@ mod tests {
let max_complete_transaction_status_slot = Arc::new(AtomicU64::default());
let max_complete_rewards_slot = Arc::new(AtomicU64::default());
let rpc_subscriptions = Arc::new(RpcSubscriptions::new_for_tests(
&Arc::new(AtomicBool::new(false)),
Arc::new(AtomicBool::new(false)),
max_complete_transaction_status_slot,
max_complete_rewards_slot,
bank_forks.clone(),
@ -878,7 +878,7 @@ mod tests {
let max_complete_transaction_status_slot = Arc::new(AtomicU64::default());
let max_complete_rewards_slot = Arc::new(AtomicU64::default());
let rpc_subscriptions = Arc::new(RpcSubscriptions::new_for_tests(
&Arc::new(AtomicBool::new(false)),
Arc::new(AtomicBool::new(false)),
max_complete_transaction_status_slot,
max_complete_rewards_slot,
bank_forks.clone(),
@ -1006,7 +1006,7 @@ mod tests {
let max_complete_transaction_status_slot = Arc::new(AtomicU64::default());
let max_complete_rewards_slot = Arc::new(AtomicU64::default());
let rpc_subscriptions = Arc::new(RpcSubscriptions::new_for_tests(
&Arc::new(AtomicBool::new(false)),
Arc::new(AtomicBool::new(false)),
max_complete_transaction_status_slot,
max_complete_rewards_slot,
bank_forks.clone(),
@ -1145,7 +1145,7 @@ mod tests {
let max_complete_transaction_status_slot = Arc::new(AtomicU64::default());
let max_complete_rewards_slot = Arc::new(AtomicU64::default());
let rpc_subscriptions = Arc::new(RpcSubscriptions::new_for_tests(
&exit,
exit,
max_complete_transaction_status_slot,
max_complete_rewards_slot,
bank_forks.clone(),
@ -1201,7 +1201,7 @@ mod tests {
let max_complete_transaction_status_slot = Arc::new(AtomicU64::default());
let max_complete_rewards_slot = Arc::new(AtomicU64::default());
let subscriptions = Arc::new(RpcSubscriptions::new_for_tests(
&exit,
exit,
max_complete_transaction_status_slot,
max_complete_rewards_slot,
bank_forks.clone(),
@ -1356,7 +1356,7 @@ mod tests {
let max_complete_transaction_status_slot = Arc::new(AtomicU64::default());
let max_complete_rewards_slot = Arc::new(AtomicU64::default());
let subscriptions = Arc::new(RpcSubscriptions::new_for_tests(
&exit,
exit,
max_complete_transaction_status_slot,
max_complete_rewards_slot,
bank_forks,

2
rpc/src/rpc_pubsub_service.rs
View File

@ -492,7 +492,7 @@ mod tests {
let optimistically_confirmed_bank =
OptimisticallyConfirmedBank::locked_from_bank_forks_root(&bank_forks);
let subscriptions = Arc::new(RpcSubscriptions::new_for_tests(
&exit,
exit,
max_complete_transaction_status_slot,
max_complete_rewards_slot,
bank_forks,

2
rpc/src/rpc_service.rs
View File

@ -615,7 +615,7 @@ mod tests {
..
} = create_genesis_config(10_000);
let exit = Arc::new(AtomicBool::new(false));
let validator_exit = create_validator_exit(&exit);
let validator_exit = create_validator_exit(exit.clone());
let bank = Bank::new_for_tests(&genesis_config);
let cluster_info = Arc::new(new_test_cluster_info());
let ip_addr = IpAddr::V4(Ipv4Addr::UNSPECIFIED);

42
rpc/src/rpc_subscriptions.rs
View File

@ -527,7 +527,7 @@ impl Drop for RpcSubscriptions {
impl RpcSubscriptions {
pub fn new(
exit: &Arc<AtomicBool>,
exit: Arc<AtomicBool>,
max_complete_transaction_status_slot: Arc<AtomicU64>,
max_complete_rewards_slot: Arc<AtomicU64>,
blockstore: Arc<Blockstore>,
@ -549,7 +549,7 @@ impl RpcSubscriptions {
}
pub fn new_for_tests(
exit: &Arc<AtomicBool>,
exit: Arc<AtomicBool>,
max_complete_transaction_status_slot: Arc<AtomicU64>,
max_complete_rewards_slot: Arc<AtomicU64>,
bank_forks: Arc<RwLock<BankForks>>,
@ -572,7 +572,7 @@ impl RpcSubscriptions {
}
pub fn new_for_tests_with_blockstore(
exit: &Arc<AtomicBool>,
exit: Arc<AtomicBool>,
max_complete_transaction_status_slot: Arc<AtomicU64>,
max_complete_rewards_slot: Arc<AtomicU64>,
blockstore: Arc<Blockstore>,
@ -608,7 +608,7 @@ impl RpcSubscriptions {
}
pub fn new_with_config(
exit: &Arc<AtomicBool>,
exit: Arc<AtomicBool>,
max_complete_transaction_status_slot: Arc<AtomicU64>,
max_complete_rewards_slot: Arc<AtomicU64>,
blockstore: Arc<Blockstore>,
@ -620,7 +620,6 @@ impl RpcSubscriptions {
) -> Self {
let (notification_sender, notification_receiver) = crossbeam_channel::unbounded();
let exit_clone = exit.clone();
let subscriptions = SubscriptionsTracker::new(bank_forks.clone());
let (broadcast_sender, _) = broadcast::channel(config.queue_capacity_items);
@ -636,6 +635,7 @@ impl RpcSubscriptions {
let t_cleanup = if notification_threads == 0 {
None
} else {
let exit = exit.clone();
Some(
Builder::new()
.name("solRpcNotifier".to_string())
@ -650,7 +650,7 @@ impl RpcSubscriptions {
rpc_notifier_ready.fetch_or(true, Ordering::Relaxed);
}
Self::process_notifications(
exit_clone,
exit,
max_complete_transaction_status_slot,
max_complete_rewards_slot,
blockstore,
@ -680,7 +680,7 @@ impl RpcSubscriptions {
Some(notification_sender)
},
t_cleanup,
exit: exit.clone(),
exit,
control,
}
}
@ -697,7 +697,7 @@ impl RpcSubscriptions {
let optimistically_confirmed_bank =
OptimisticallyConfirmedBank::locked_from_bank_forks_root(&bank_forks);
Self::new(
&Arc::new(AtomicBool::new(false)),
Arc::new(AtomicBool::new(false)),
max_complete_transaction_status_slot,
max_complete_rewards_slot,
blockstore,
@ -1333,7 +1333,7 @@ pub(crate) mod tests {
let max_complete_transaction_status_slot = Arc::new(AtomicU64::default());
let max_complete_rewards_slot = Arc::new(AtomicU64::default());
let subscriptions = Arc::new(RpcSubscriptions::new_for_tests(
&exit,
exit,
max_complete_transaction_status_slot,
max_complete_rewards_slot,
bank_forks.clone(),
@ -1478,7 +1478,7 @@ pub(crate) mod tests {
let max_complete_transaction_status_slot = Arc::new(AtomicU64::default());
let max_complete_rewards_slot = Arc::new(AtomicU64::default());
let subscriptions = Arc::new(RpcSubscriptions::new_for_tests_with_blockstore(
&exit,
exit,
max_complete_transaction_status_slot,
max_complete_rewards_slot,
blockstore.clone(),
@ -1598,7 +1598,7 @@ pub(crate) mod tests {
let max_complete_transaction_status_slot = Arc::new(AtomicU64::default());
let max_complete_rewards_slot = Arc::new(AtomicU64::default());
let subscriptions = Arc::new(RpcSubscriptions::new_for_tests_with_blockstore(
&exit,
exit,
max_complete_transaction_status_slot,
max_complete_rewards_slot,
blockstore.clone(),
@ -1716,7 +1716,7 @@ pub(crate) mod tests {
let max_complete_transaction_status_slot = Arc::new(AtomicU64::default());
let max_complete_rewards_slot = Arc::new(AtomicU64::default());
let subscriptions = Arc::new(RpcSubscriptions::new_for_tests_with_blockstore(
&exit,
exit,
max_complete_transaction_status_slot,
max_complete_rewards_slot,
blockstore.clone(),
@ -1849,7 +1849,7 @@ pub(crate) mod tests {
let max_complete_transaction_status_slot = Arc::new(AtomicU64::default());
let max_complete_rewards_slot = Arc::new(AtomicU64::default());
let subscriptions = Arc::new(RpcSubscriptions::new_for_tests(
&exit,
exit,
max_complete_transaction_status_slot,
max_complete_rewards_slot,
bank_forks,
@ -1999,7 +1999,7 @@ pub(crate) mod tests {
let max_complete_transaction_status_slot = Arc::new(AtomicU64::default());
let max_complete_rewards_slot = Arc::new(AtomicU64::default());
let subscriptions = Arc::new(RpcSubscriptions::new_for_tests(
&exit,
exit,
max_complete_transaction_status_slot,
max_complete_rewards_slot,
bank_forks.clone(),
@ -2175,7 +2175,7 @@ pub(crate) mod tests {
let max_complete_transaction_status_slot = Arc::new(AtomicU64::default());
let max_complete_rewards_slot = Arc::new(AtomicU64::default());
let subscriptions = Arc::new(RpcSubscriptions::new_for_tests(
&exit,
exit,
max_complete_transaction_status_slot,
max_complete_rewards_slot,
bank_forks.clone(),
@ -2290,7 +2290,7 @@ pub(crate) mod tests {
let max_complete_transaction_status_slot = Arc::new(AtomicU64::default());
let max_complete_rewards_slot = Arc::new(AtomicU64::default());
let subscriptions = Arc::new(RpcSubscriptions::new_for_tests(
&exit,
exit,
max_complete_transaction_status_slot,
max_complete_rewards_slot,
bank_forks.clone(),
@ -2483,7 +2483,7 @@ pub(crate) mod tests {
let max_complete_transaction_status_slot = Arc::new(AtomicU64::default());
let max_complete_rewards_slot = Arc::new(AtomicU64::default());
let subscriptions = Arc::new(RpcSubscriptions::new_for_tests(
&exit,
exit,
max_complete_transaction_status_slot,
max_complete_rewards_slot,
bank_forks,
@ -2659,7 +2659,7 @@ pub(crate) mod tests {
let max_complete_transaction_status_slot = Arc::new(AtomicU64::default());
let max_complete_rewards_slot = Arc::new(AtomicU64::default());
let subscriptions = Arc::new(RpcSubscriptions::new_for_tests(
&exit,
exit,
max_complete_transaction_status_slot,
max_complete_rewards_slot,
bank_forks,
@ -2706,7 +2706,7 @@ pub(crate) mod tests {
let max_complete_transaction_status_slot = Arc::new(AtomicU64::default());
let max_complete_rewards_slot = Arc::new(AtomicU64::default());
let subscriptions = Arc::new(RpcSubscriptions::new_for_tests(
&exit,
exit,
max_complete_transaction_status_slot,
max_complete_rewards_slot,
bank_forks,
@ -2767,7 +2767,7 @@ pub(crate) mod tests {
let max_complete_transaction_status_slot = Arc::new(AtomicU64::default());
let max_complete_rewards_slot = Arc::new(AtomicU64::default());
let subscriptions = Arc::new(RpcSubscriptions::new_for_tests(
&exit,
exit,
max_complete_transaction_status_slot,
max_complete_rewards_slot,
bank_forks.clone(),
@ -2970,7 +2970,7 @@ pub(crate) mod tests {
let optimistically_confirmed_bank =
OptimisticallyConfirmedBank::locked_from_bank_forks_root(&bank_forks);
let subscriptions = Arc::new(RpcSubscriptions::new_for_tests(
&exit,
exit,
max_complete_transaction_status_slot,
max_complete_rewards_slot,
bank_forks.clone(),

5
rpc/src/transaction_status_service.rs
View File

@ -32,9 +32,8 @@ impl TransactionStatusService {
transaction_notifier: Option<TransactionNotifierLock>,
blockstore: Arc<Blockstore>,
enable_extended_tx_metadata_storage: bool,
exit: &Arc<AtomicBool>,
exit: Arc<AtomicBool>,
) -> Self {
let exit = exit.clone();
let thread_hdl = Builder::new()
.name("solTxStatusWrtr".to_string())
.spawn(move || loop {
@ -442,7 +441,7 @@ pub(crate) mod tests {
Some(test_notifier.clone()),
blockstore,
false,
&exit,
exit.clone(),
);
transaction_status_sender

12
runtime/src/accounts_index_storage.rs
View File

@ -58,7 +58,7 @@ impl BgThreads {
in_mem: &[Arc<InMemAccountsIndex<T, U>>],
threads: usize,
can_advance_age: bool,
exit: &Arc<AtomicBool>,
exit: Arc<AtomicBool>,
) -> Self {
// stop signal used for THIS batch of bg threads
let local_exit = Arc::new(AtomicBool::default());
@ -68,8 +68,8 @@ impl BgThreads {
// the first thread we start is special
let can_advance_age = can_advance_age && idx == 0;
let storage_ = Arc::clone(storage);
let local_exit_ = Arc::clone(&local_exit);
let system_exit_ = Arc::clone(exit);
let local_exit = local_exit.clone();
let system_exit = exit.clone();
let in_mem_ = in_mem.to_vec();
// note that using rayon here causes us to exhaust # rayon threads and many tests running in parallel deadlock
@ -77,7 +77,7 @@ impl BgThreads {
.name(format!("solIdxFlusher{idx:02}"))
.spawn(move || {
storage_.background(
vec![local_exit_, system_exit_],
vec![local_exit, system_exit],
in_mem_,
can_advance_age,
);
@ -123,7 +123,7 @@ impl<T: IndexValue, U: DiskIndexValue + From<T> + Into<T>> AccountsIndexStorage<
&self.in_mem,
Self::num_threads(),
false, // cannot advance age from any of these threads
&self.exit,
self.exit.clone(),
));
}
self.storage.set_startup(value);
@ -167,7 +167,7 @@ impl<T: IndexValue, U: DiskIndexValue + From<T> + Into<T>> AccountsIndexStorage<
.collect::<Vec<_>>();
Self {
_bg_threads: BgThreads::new(&storage, &in_mem, threads, true, &exit),
_bg_threads: BgThreads::new(&storage, &in_mem, threads, true, exit.clone()),
storage,
in_mem,
startup_worker_threads: Mutex::default(),

4
streamer/src/streamer.rs
View File

@ -103,7 +103,7 @@ pub type Result<T> = std::result::Result<T, StreamerError>;
fn recv_loop(
socket: &UdpSocket,
exit: Arc<AtomicBool>,
exit: &AtomicBool,
packet_batch_sender: &PacketBatchSender,
recycler: &PacketBatchRecycler,
stats: &StreamerReceiveStats,
@ -173,7 +173,7 @@ pub fn receiver(
.spawn(move || {
let _ = recv_loop(
&socket,
exit,
&exit,
&packet_batch_sender,
&recycler,
&stats,

2
validator/src/admin_rpc_service.rs
View File

@ -920,7 +920,7 @@ mod tests {
SocketAddrSpace::Unspecified,
));
let exit = Arc::new(AtomicBool::new(false));
let validator_exit = create_validator_exit(&exit);
let validator_exit = create_validator_exit(exit);
let (bank_forks, vote_keypair) = new_bank_forks_with_config(BankTestConfig {
secondary_indexes: config.account_indexes,
});

2
validator/src/bootstrap.rs
View File

@ -171,7 +171,7 @@ fn start_gossip_node(
gossip_validators,
should_check_duplicate_instance,
None,
&gossip_exit_flag,
gossip_exit_flag.clone(),
);
(cluster_info, gossip_exit_flag, gossip_service)
}

2
validator/src/dashboard.rs
View File

@ -195,7 +195,7 @@ impl Dashboard {
async fn wait_for_validator_startup(
ledger_path: &Path,
exit: &Arc<AtomicBool>,
exit: &AtomicBool,
progress_bar: ProgressBar,
refresh_interval: Duration,
) -> Option<(SocketAddr, SystemTime)> {