Struct ChokingAlgorithm 

pub struct ChokingAlgorithm { /* private fields */ }

BitTorrent choking algorithm implementation (tit-for-tat strategy)

This implements the standard BT choking algorithm:

• Top K peers by score get unchoked (reciprocity-based)
• One additional slot for optimistic unchoke (random selection)
• Snubbed peers are penalized heavily

The algorithm minimizes churn by only changing state when necessary.

Implementations

impl ChokingAlgorithm

pub fn new(config: ChokingConfig) -> Self

Create a new choking algorithm with the given configuration

pub fn add_peer(&mut self, stats: PeerStats)

Add a peer to be managed by the algorithm

pub fn remove_peer(&mut self, idx: usize)

Remove a peer at the given index

pub fn len(&self) -> usize

Returns the number of peers being managed

pub fn is_empty(&self) -> bool

Returns true if there are no peers

pub fn rotate_choke(&mut self) -> Vec<ChokeAction>

Core algorithm: called every ~10 seconds (config.choke_rotation_interval_secs)

This performs the tit-for-tat choke rotation:

1. Check and mark snubbed peers (timeout-based)
2. Calculate score for each peer
3. Sort by score descending
4. Top K get Unchoke, rest get Choke BUT: keep currently unchoked peers unchoked if they’re still in top K (avoid churn - only change what’s necessary)
5. Return only the actions that changed state

pub fn optimistically_unchoke(&mut self) -> Option<usize>

Called every ~30 seconds (config.optimistic_unchoke_interval_secs)

Selects ONE choked+interested peer for optimistic unchoke. This gives new/unknown peers a chance to prove themselves.

Uses round-robin rotation among eligible non-snubbed peers to ensure fair distribution of the optimistic unchoke slot.

Returns Some(index) if found, None if no eligible peer

pub fn rotate_optimistic_unchoked(&mut self, eligible_peers: &[usize]) -> usize

Rotate which peer gets the optimistic unchoke slot using round-robin.

Picks a different peer than the current one when possible, cycling through eligible peers in order.

Arguments

• eligible_peers - Indices of peers that are eligible for optimistic unchoke

Returns

The index of the selected peer from the eligible set

pub fn on_data_received(&mut self, peer_idx: usize, bytes: u64)

Called whenever we receive data from a peer. Automatically unsnubs the peer if it was in the explicit snubbed set.

pub fn mark_peer_snubbed(&mut self, peer_id: usize)

Explicitly mark a peer as snubbed (algorithm-level).

This adds the peer to the snubbed_peers set, which causes calculate_peer_score to return -1000 for this peer, ensuring they always get choked on the next rotation.

pub fn unsnub_peer(&mut self, peer_id: usize) -> bool

Remove a peer from the explicit snubbed set (they sent data again).

Returns true if the peer was actually in the snubbed set (newly un-snubbed), false if they were not snubbed.

pub fn is_explicitly_snubbed(&self, peer_id: usize) -> bool

Check if a peer is in the explicit snubbed set.

pub fn snubbed_count(&self) -> usize

Get the number of explicitly snubbed peers.

pub fn check_snubbed_peers(&mut self) -> Vec<usize>

Check all peers for snubbed status Returns indices of newly snubbed peers

pub fn get_peer_mut(&mut self, idx: usize) -> Option<&mut PeerStats>

Get mutable reference to peer stats

pub fn get_peer(&self, idx: usize) -> Option<&PeerStats>

Get reference to peer stats

pub fn peers(&self) -> &[PeerStats]

Get all peers as a slice

pub fn config(&self) -> &ChokingConfig

Get reference to configuration