use crate::encoder::{FileHashes, RecoveryEncoder, RecoverySlice};
use crate::packet::SliceChecksum;
use std::collections::TryReserveError;
use std::sync::Arc;
pub enum Par2Work {
Slice {
data: Vec<u8>,
actual_len: usize,
is_last_of_file: bool,
},
}
pub struct Par2Worker {
tx: std::sync::mpsc::SyncSender<Par2Work>,
free_rx: std::sync::Mutex<std::sync::mpsc::Receiver<Vec<u8>>>,
handle: std::thread::JoinHandle<(Vec<RecoverySlice>, Vec<SliceChecksum>, Vec<FileHashes>)>,
}
pub const DEFAULT_CHANNEL_DEPTH: usize = 64;
impl Par2Worker {
pub fn spawn(enc: RecoveryEncoder, compute_hashes: bool, channel_depth: usize) -> Self {
Self::spawn_inner(enc, compute_hashes, channel_depth, None)
}
pub fn spawn_with_thread_pool(
enc: RecoveryEncoder,
compute_hashes: bool,
channel_depth: usize,
thread_pool: Arc<rayon::ThreadPool>,
) -> Self {
Self::spawn_inner(enc, compute_hashes, channel_depth, Some(thread_pool))
}
fn spawn_inner(
enc: RecoveryEncoder,
compute_hashes: bool,
channel_depth: usize,
thread_pool: Option<Arc<rayon::ThreadPool>>,
) -> Self {
let channel_depth = channel_depth.max(2); let (tx, rx) = std::sync::mpsc::sync_channel::<Par2Work>(channel_depth);
let (free_tx, free_rx) = std::sync::mpsc::channel::<Vec<u8>>();
let handle = std::thread::spawn(move || {
let (rs_tx, rs_rx) = std::sync::mpsc::sync_channel::<Vec<u8>>(channel_depth);
let (hash_tx, hash_rx) = std::sync::mpsc::sync_channel::<Vec<FileHashes>>(1);
let hasher_handle = if compute_hashes {
Some(std::thread::spawn(move || {
let mut hashes = Vec::new();
let mut current_hasher = crate::encoder::FileHasher::new();
while let Ok(work) = rx.recv() {
match work {
Par2Work::Slice {
data,
actual_len,
is_last_of_file,
} => {
current_hasher.update(&data[..actual_len]);
if is_last_of_file {
hashes.push(current_hasher.finish());
current_hasher = crate::encoder::FileHasher::new();
}
let _ = rs_tx.send(data);
}
}
}
let _ = hash_tx.send(hashes);
}))
} else {
std::thread::spawn(move || {
while let Ok(work) = rx.recv() {
match work {
Par2Work::Slice { data, .. } => {
let _ = rs_tx.send(data);
}
}
}
});
None
};
let encode = move || {
let mut enc = enc;
while let Ok(slice) = rs_rx.recv() {
enc.add_slice(slice);
for buf in enc.drain_free_buffers() {
let _ = free_tx.send(buf);
}
}
enc.finish()
};
let (slices, checksums) = if let Some(thread_pool) = thread_pool {
thread_pool.install(encode)
} else {
encode()
};
let hashes = if compute_hashes {
match hash_rx.recv() {
Ok(hashes) => hashes,
Err(_) => {
if let Some(h) = hasher_handle {
match h.join() {
Err(payload) => std::panic::resume_unwind(payload),
Ok(()) => unreachable!(
"hasher thread returned normally but never sent hashes"
),
}
}
Vec::new()
}
}
} else {
Vec::new()
};
(slices, checksums, hashes)
});
Self {
tx,
free_rx: std::sync::Mutex::new(free_rx),
handle,
}
}
pub fn try_take_buffer(&self, slice_size: usize) -> Result<Vec<u8>, TryReserveError> {
match self.free_rx.lock().unwrap().try_recv() {
Ok(mut buf) => {
buf.clear();
Ok(buf)
}
Err(_) => {
let mut buf = Vec::new();
buf.try_reserve_exact(slice_size)?;
Ok(buf)
}
}
}
pub fn take_buffer(&self, slice_size: usize) -> Vec<u8> {
self.try_take_buffer(slice_size).unwrap_or_else(|e| {
panic!(
"PAR2 slice buffer allocation failed ({} bytes): {e}",
slice_size
)
})
}
pub fn send_slice(&self, slice: Vec<u8>, actual_len: usize, is_last_of_file: bool) {
self.tx
.send(Par2Work::Slice {
data: slice,
actual_len,
is_last_of_file,
})
.expect("par2 worker thread died");
}
pub fn finish(self) -> (Vec<RecoverySlice>, Vec<SliceChecksum>, Vec<FileHashes>) {
drop(self.tx); self.handle.join().expect("par2 worker thread panicked")
}
}