danvics/oxipng
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Unbreak no-default-features

Browse source 
In order to avoid problems with mutable references,
the approach is to use the eval sender for non-parallel.
Computations will still be done synchronously
with the fake synchronous rayon module.
This commit is contained in:
Josh Holmer 2020-04-15 12:37:52 -04:00
parent 43735086d1
commit 4ef92089d5
1 changed files with 1 additions and 30 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

31
src/evaluate.rs
View file

@ -17,7 +17,6 @@ use rayon;
use rayon::prelude::*; use rayon::prelude::*;
use std::sync::atomic::AtomicUsize; use std::sync::atomic::AtomicUsize;
use std::sync::atomic::Ordering::SeqCst; use std::sync::atomic::Ordering::SeqCst;
#[cfg(feature = "parallel")]
use std::sync::mpsc::*; use std::sync::mpsc::*;
use std::sync::Arc; use std::sync::Arc;
use std::thread; use std::thread;
@ -47,46 +46,30 @@ pub(crate) struct Evaluator {
nth: AtomicUsize, nth: AtomicUsize,
best_candidate_size: Arc<AtomicMin>, best_candidate_size: Arc<AtomicMin>,
/// images are sent to the thread for evaluation /// images are sent to the thread for evaluation
#[cfg(feature = "parallel")]
eval_send: SyncSender<Candidate>, eval_send: SyncSender<Candidate>,
// the thread helps evaluate images asynchronously // the thread helps evaluate images asynchronously
#[cfg(feature = "parallel")]
eval_thread: thread::JoinHandle<Option<Candidate>>, eval_thread: thread::JoinHandle<Option<Candidate>>,
// in non-parallel mode, images are evaluated synchronously
#[cfg(not(feature = "parallel"))]
eval_best_candidate: Option<Candidate>,
} }
impl Evaluator { impl Evaluator {
pub fn new(deadline: Arc<Deadline>) -> Self { pub fn new(deadline: Arc<Deadline>) -> Self {
#[cfg(feature = "parallel")]
let (tx, rx) = sync_channel(4); let (tx, rx) = sync_channel(4);
Self { Self {
deadline, deadline,
best_candidate_size: Arc::new(AtomicMin::new(None)), best_candidate_size: Arc::new(AtomicMin::new(None)),
nth: AtomicUsize::new(0), nth: AtomicUsize::new(0),
#[cfg(feature = "parallel")]
eval_send: tx, eval_send: tx,
#[cfg(feature = "parallel")]
eval_thread: thread::spawn(move || rx.into_iter().min_by_key(Candidate::cmp_key)), eval_thread: thread::spawn(move || rx.into_iter().min_by_key(Candidate::cmp_key)),
#[cfg(not(feature = "parallel"))]
eval_best_candidate: None,
} }
} }
/// Wait for all evaluations to finish and return smallest reduction /// Wait for all evaluations to finish and return smallest reduction
/// Or `None` if all reductions were worse than baseline. /// Or `None` if all reductions were worse than baseline.
#[cfg(feature = "parallel")]
fn get_best_candidate(self) -> Option<Candidate> { fn get_best_candidate(self) -> Option<Candidate> {
drop(self.eval_send); // disconnect the sender, breaking the loop in the thread drop(self.eval_send); // disconnect the sender, breaking the loop in the thread
self.eval_thread.join().expect("eval thread") self.eval_thread.join().expect("eval thread")
} }
#[cfg(not(feature = "parallel"))]
fn get_best_candidate(self) -> Option<Candidate> {
self.eval_best_candidate
}
pub fn get_result(self) -> Option<PngData> { pub fn get_result(self) -> Option<PngData> {
self.get_best_candidate().map(|candidate| candidate.image) self.get_best_candidate().map(|candidate| candidate.image)
} }
@ -108,7 +91,6 @@ impl Evaluator {
let best_candidate_size = self.best_candidate_size.clone(); let best_candidate_size = self.best_candidate_size.clone();
// sends it off asynchronously for compression, // sends it off asynchronously for compression,
// but results will be collected via the message queue // but results will be collected via the message queue
#[cfg(feature = "parallel")]
let eval_send = self.eval_send.clone(); let eval_send = self.eval_send.clone();
rayon::spawn(move || { rayon::spawn(move || {
let filters_iter = STD_FILTERS.par_iter().with_max_len(1); let filters_iter = STD_FILTERS.par_iter().with_max_len(1);
@ -144,18 +126,7 @@ impl Evaluator {
nth, nth,
}; };
#[cfg(feature = "parallel")] eval_send.send(new).expect("send");
{
eval_send.send(new).expect("send");
}
#[cfg(not(feature = "parallel"))]
{
match self.eval_best_candidate {
Some(prev) if prev.cmp_key() < new.cmp_key() => {}
_ => self.eval_best_candidate = Some(new),
}
}
} }
}); });
}); });