use std::sync::Arc;
use tracing::trace;
use super::PieceStatMan;
use super::bitfield_util::test_bit;
pub struct RarestPieceSelector {
piece_stat_man: Arc<PieceStatMan>,
}
impl RarestPieceSelector {
pub fn new(piece_stat_man: Arc<PieceStatMan>) -> Self {
RarestPieceSelector { piece_stat_man }
}
pub fn select(&self, bitfield: &[u8], nbits: usize) -> Option<usize> {
let order = self.piece_stat_man.order();
let counts = self.piece_stat_man.counts_ref();
if order.len() < nbits || counts.len() < nbits {
trace!(
order_len = order.len(),
counts_len = counts.len(),
nbits,
"RarestPieceSelector: order/counts shorter than nbits"
);
return None;
}
let mut min_count = u32::MAX;
let mut best_idx = nbits;
for &idx in order.iter().take(nbits) {
if test_bit(bitfield, nbits, idx) && counts[idx] < min_count {
min_count = counts[idx];
best_idx = idx;
}
}
if best_idx == nbits {
trace!(nbits, "RarestPieceSelector: no available piece found");
None
} else {
trace!(
best_idx,
min_count, nbits, "RarestPieceSelector: selected piece"
);
Some(best_idx)
}
}
pub fn piece_stat_man(&self) -> &PieceStatMan {
&self.piece_stat_man
}
}
pub struct PriorityPieceSelector {
prioritized_pieces: Vec<usize>,
inner: Box<PieceSelectorKind>,
}
impl PriorityPieceSelector {
pub fn new(inner: PieceSelectorKind) -> Self {
PriorityPieceSelector {
prioritized_pieces: Vec::new(),
inner: Box::new(inner),
}
}
pub fn set_priority_pieces(&mut self, pieces: Vec<usize>) {
trace!(
count = pieces.len(),
"PriorityPieceSelector: setting priority pieces"
);
self.prioritized_pieces = pieces;
}
pub fn prioritized_pieces(&self) -> &[usize] {
&self.prioritized_pieces
}
pub fn select(&self, bitfield: &[u8], nbits: usize) -> Option<usize> {
for &p in &self.prioritized_pieces {
if test_bit(bitfield, nbits, p) {
trace!(
index = p,
nbits, "PriorityPieceSelector: selected prioritized piece"
);
return Some(p);
}
}
trace!(
nbits,
"PriorityPieceSelector: no prioritized piece available, delegating"
);
self.inner.select(bitfield, nbits)
}
}
pub enum PieceSelectorKind {
Rarest(RarestPieceSelector),
Priority(PriorityPieceSelector),
}
impl PieceSelectorKind {
pub fn select(&self, bitfield: &[u8], nbits: usize) -> Option<usize> {
match self {
PieceSelectorKind::Rarest(r) => r.select(bitfield, nbits),
PieceSelectorKind::Priority(p) => p.select(bitfield, nbits),
}
}
}
impl std::fmt::Debug for PieceSelectorKind {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
PieceSelectorKind::Rarest(_) => f.debug_struct("PieceSelectorKind::Rarest").finish(),
PieceSelectorKind::Priority(p) => f
.debug_struct("PieceSelectorKind::Priority")
.field("prioritized_count", &p.prioritized_pieces.len())
.finish(),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
fn build_bitfield(nbits: usize, set_bits: &[usize]) -> Vec<u8> {
let num_bytes = nbits.div_ceil(8);
let mut bf = vec![0u8; num_bytes];
for &bit in set_bits {
let byte = bit / 8;
let bit_pos = 7 - (bit % 8);
if byte < bf.len() {
bf[byte] |= 1 << bit_pos;
}
}
bf
}
#[test]
fn test_rarest_select_basic() {
let man = Arc::new(PieceStatMan::new(10, false));
let selector = RarestPieceSelector::new(man);
let bf = build_bitfield(10, &[0, 1, 2]);
let result = selector.select(&bf, 10);
assert!(result.is_some());
assert_eq!(result.unwrap(), 0);
}
#[test]
fn test_rarest_select_with_counts() {
let man = Arc::new(PieceStatMan::new(10, false));
man.add_piece_stats_index(0);
let selector = RarestPieceSelector::new(man);
let bf = build_bitfield(10, &[0, 1, 2]);
let result = selector.select(&bf, 10);
assert!(result.is_some());
assert_eq!(result.unwrap(), 1);
}
#[test]
fn test_rarest_select_no_available_piece() {
let man = Arc::new(PieceStatMan::new(10, false));
let selector = RarestPieceSelector::new(man);
let bf = vec![0u8; 2]; let result = selector.select(&bf, 10);
assert!(result.is_none());
}
#[test]
fn test_rarest_select_all_bits_set() {
let man = Arc::new(PieceStatMan::new(8, false));
let selector = RarestPieceSelector::new(man);
let bf = vec![0xFF];
let result = selector.select(&bf, 8);
assert!(result.is_some());
assert_eq!(result.unwrap(), 0);
}
#[test]
fn test_rarest_select_single_piece() {
let man = Arc::new(PieceStatMan::new(8, false));
let selector = RarestPieceSelector::new(man);
let bf = build_bitfield(8, &[5]);
let result = selector.select(&bf, 8);
assert!(result.is_some());
assert_eq!(result.unwrap(), 5);
}
#[test]
fn test_rarest_select_prefers_lower_count() {
let man = Arc::new(PieceStatMan::new(8, false));
for _ in 0..5 {
man.add_piece_stats_index(3);
}
man.add_piece_stats_index(7);
let selector = RarestPieceSelector::new(man);
let bf = build_bitfield(8, &[3, 7]);
let result = selector.select(&bf, 8);
assert!(result.is_some());
assert_eq!(result.unwrap(), 7);
}
#[test]
fn test_rarest_select_zero_nbits() {
let man = Arc::new(PieceStatMan::new(0, false));
let selector = RarestPieceSelector::new(man);
let bf: Vec<u8> = vec![];
let result = selector.select(&bf, 0);
assert!(result.is_none());
}
#[test]
fn test_rarest_select_matching_cpp_test() {
let man = Arc::new(PieceStatMan::new(10, false));
let selector = RarestPieceSelector::new(Arc::clone(&man));
let bf = build_bitfield(10, &[0, 1]);
man.add_piece_stats_index(0);
let result = selector.select(&bf, 10);
assert!(result.is_some());
assert_eq!(result.unwrap(), 1);
man.add_piece_stats_index(1);
let result = selector.select(&bf, 10);
assert!(result.is_some());
assert_eq!(result.unwrap(), 0);
}
#[test]
fn test_priority_select_with_prioritized_pieces() {
let man = Arc::new(PieceStatMan::new(256, false));
let inner = PieceSelectorKind::Rarest(RarestPieceSelector::new(man));
let mut selector = PriorityPieceSelector::new(inner);
selector.set_priority_pieces(vec![1, 200]);
let bf = build_bitfield(256, &[1, 200]);
let result = selector.select(&bf, 256);
assert!(result.is_some());
assert_eq!(result.unwrap(), 1);
}
#[test]
fn test_priority_select_falls_through_when_first_not_available() {
let man = Arc::new(PieceStatMan::new(256, false));
let inner = PieceSelectorKind::Rarest(RarestPieceSelector::new(man));
let mut selector = PriorityPieceSelector::new(inner);
selector.set_priority_pieces(vec![1, 200]);
let bf = build_bitfield(256, &[200]);
let result = selector.select(&bf, 256);
assert!(result.is_some());
assert_eq!(result.unwrap(), 200);
}
#[test]
fn test_priority_select_delegates_when_no_priority_available() {
let man = Arc::new(PieceStatMan::new(256, false));
let inner = PieceSelectorKind::Rarest(RarestPieceSelector::new(Arc::clone(&man)));
let mut selector = PriorityPieceSelector::new(inner);
selector.set_priority_pieces(vec![1, 200]);
let bf = build_bitfield(256, &[50]);
let result = selector.select(&bf, 256);
assert!(result.is_some());
assert_eq!(result.unwrap(), 50);
}
#[test]
fn test_priority_select_no_prioritized_pieces() {
let man = Arc::new(PieceStatMan::new(8, false));
let inner = PieceSelectorKind::Rarest(RarestPieceSelector::new(Arc::clone(&man)));
let selector = PriorityPieceSelector::new(inner);
let bf = build_bitfield(8, &[3]);
let result = selector.select(&bf, 8);
assert!(result.is_some());
assert_eq!(result.unwrap(), 3);
}
#[test]
fn test_priority_select_none_available() {
let man = Arc::new(PieceStatMan::new(8, false));
let inner = PieceSelectorKind::Rarest(RarestPieceSelector::new(man));
let mut selector = PriorityPieceSelector::new(inner);
selector.set_priority_pieces(vec![1, 2]);
let bf = vec![0u8; 1];
let result = selector.select(&bf, 8);
assert!(result.is_none());
}
#[test]
fn test_priority_select_set_priority_replaces() {
let man = Arc::new(PieceStatMan::new(8, false));
let inner = PieceSelectorKind::Rarest(RarestPieceSelector::new(Arc::clone(&man)));
let mut selector = PriorityPieceSelector::new(inner);
selector.set_priority_pieces(vec![0]);
let bf = build_bitfield(8, &[0, 3]);
assert_eq!(selector.select(&bf, 8), Some(0));
selector.set_priority_pieces(vec![3]);
assert_eq!(selector.select(&bf, 8), Some(3));
}
#[test]
fn test_priority_nested_priority() {
let man = Arc::new(PieceStatMan::new(8, false));
let rarest = PieceSelectorKind::Rarest(RarestPieceSelector::new(Arc::clone(&man)));
let mut inner_priority = PriorityPieceSelector::new(rarest);
inner_priority.set_priority_pieces(vec![2]);
let mut outer_priority =
PriorityPieceSelector::new(PieceSelectorKind::Priority(inner_priority));
outer_priority.set_priority_pieces(vec![0]);
let bf = build_bitfield(8, &[0, 2, 5]);
assert_eq!(outer_priority.select(&bf, 8), Some(0));
let bf = build_bitfield(8, &[2, 5]);
assert_eq!(outer_priority.select(&bf, 8), Some(2));
let bf = build_bitfield(8, &[5]);
assert_eq!(outer_priority.select(&bf, 8), Some(5));
}
#[test]
fn test_priority_select_matching_cpp_test() {
let man = Arc::new(PieceStatMan::new(256, false));
let inner = PieceSelectorKind::Rarest(RarestPieceSelector::new(man));
let mut selector = PriorityPieceSelector::new(inner);
selector.set_priority_pieces(vec![1, 200]);
let bf = build_bitfield(256, &[1, 200]);
assert_eq!(selector.select(&bf, 256), Some(1));
let bf = build_bitfield(256, &[200]);
assert_eq!(selector.select(&bf, 256), Some(200));
let bf = vec![0u8; 32]; assert!(selector.select(&bf, 256).is_none());
}
#[test]
fn test_piece_selector_kind_rarest_dispatch() {
let man = Arc::new(PieceStatMan::new(8, false));
let selector = PieceSelectorKind::Rarest(RarestPieceSelector::new(man));
let bf = build_bitfield(8, &[3]);
assert_eq!(selector.select(&bf, 8), Some(3));
}
#[test]
fn test_piece_selector_kind_priority_dispatch() {
let man = Arc::new(PieceStatMan::new(8, false));
let inner = PieceSelectorKind::Rarest(RarestPieceSelector::new(Arc::clone(&man)));
let mut priority = PriorityPieceSelector::new(inner);
priority.set_priority_pieces(vec![5]);
let selector = PieceSelectorKind::Priority(priority);
let bf = build_bitfield(8, &[5]);
assert_eq!(selector.select(&bf, 8), Some(5));
}
#[test]
fn test_piece_selector_kind_debug_format() {
let man = Arc::new(PieceStatMan::new(8, false));
let rarest = PieceSelectorKind::Rarest(RarestPieceSelector::new(Arc::clone(&man)));
let debug_str = format!("{:?}", rarest);
assert!(debug_str.contains("Rarest"));
let mut priority =
PriorityPieceSelector::new(PieceSelectorKind::Rarest(RarestPieceSelector::new(man)));
priority.set_priority_pieces(vec![1, 2, 3]);
let priority_kind = PieceSelectorKind::Priority(priority);
let debug_str = format!("{:?}", priority_kind);
assert!(debug_str.contains("Priority"));
assert!(debug_str.contains("3")); }
}