pub(crate) mod bam;
mod fastq;
#[cfg(feature = "paraseq")]
mod paraseq;
pub(crate) mod reject;
use std::collections::BTreeMap;
use std::io::Write;
use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
use std::sync::{Arc, Condvar, Mutex, OnceLock};
use rayon::prelude::*;
pub(crate) use bam::run_bam_to_fastq;
pub use bam::run_raw_bam;
pub(crate) fn filter_by_tags<R, I, K, W, N, J>(
records: I,
counters: Arc<Counters>,
keep: K,
weight: W,
name: N,
reject: J,
) -> Box<dyn Iterator<Item = anyhow::Result<R>> + Send>
where
R: Send + 'static,
I: Iterator<Item = anyhow::Result<R>> + Send + 'static,
K: Fn(&R) -> anyhow::Result<bool> + Send + 'static,
W: Fn(&R) -> usize + Send + 'static,
N: Fn(&R) -> String + Send + 'static,
J: Fn(&R) -> anyhow::Result<()> + Send + 'static,
{
Box::new(records.filter_map(move |item| {
let rec = match item {
Ok(rec) => rec,
Err(e) => return Some(Err(e)),
};
match keep(&rec) {
Ok(true) => Some(Ok(rec)),
Ok(false) => {
counters.input_reads.fetch_add(1, Ordering::Relaxed);
counters
.input_bases
.fetch_add(weight(&rec) as u64, Ordering::Relaxed);
counters.tag_filtered_reads.fetch_add(1, Ordering::Relaxed);
match reject(&rec) {
Ok(()) => None,
Err(e) => Some(Err(e.context(format!("read {}", name(&rec))))),
}
},
Err(e) => Some(Err(e.context(format!("read {}", name(&rec))))),
}
}))
}
pub(crate) use fastq::{run_fastq, tag_filtered_fastq};
#[cfg(feature = "paraseq")]
pub(crate) use paraseq::{run_fastq_paraseq, selected as paraseq_selected};
use crate::config::Config;
use crate::filter::{DropReason, FilterConfig};
#[derive(Clone, Copy)]
pub(crate) struct BatchPolicy {
target_weight: usize,
max_items: usize,
queue_per_worker: usize,
}
pub(crate) const FASTQ_BATCH: BatchPolicy = BatchPolicy {
target_weight: 2 * 1024 * 1024,
max_items: 128,
queue_per_worker: 2,
};
pub(crate) const BAM_BATCH: BatchPolicy = BatchPolicy {
target_weight: 1024 * 1024,
max_items: 16,
queue_per_worker: 1,
};
pub(crate) struct Batches<I, F> {
records: I,
weight: F,
policy: BatchPolicy,
}
impl<I, F> Batches<I, F> {
pub(crate) fn new(records: I, weight: F, policy: BatchPolicy) -> Self {
Self {
records,
weight,
policy,
}
}
}
impl<I, F, T> Iterator for Batches<I, F>
where
I: Iterator<Item = T>,
F: Fn(&T) -> usize,
{
type Item = Vec<T>;
fn next(&mut self) -> Option<Self::Item> {
let mut batch = Vec::with_capacity(self.policy.max_items);
let mut bases = 0usize;
while batch.len() < self.policy.max_items && bases < self.policy.target_weight {
let Some(record) = self.records.next() else {
break;
};
bases = bases.saturating_add((self.weight)(&record));
batch.push(record);
}
(!batch.is_empty()).then_some(batch)
}
}
pub(crate) trait BatchSink: Write + Send {
fn block_level(&self) -> Option<u8> {
None
}
}
impl BatchSink for Vec<u8> {}
impl BatchSink for crate::io::fastq::FastqOut {
fn block_level(&self) -> Option<u8> {
crate::io::fastq::FastqOut::block_level(self)
}
}
pub(crate) fn run_bytes_parallel<R, W, Weight, Render>(
records: impl Iterator<Item = anyhow::Result<R>> + Send,
policy: BatchPolicy,
weight: Weight,
cfg: &Config,
writer: &mut W,
render: Render,
counters: &Counters,
) -> anyhow::Result<Stats>
where
R: Send,
W: BatchSink,
Weight: Fn(&R) -> usize + Sync,
Render: Fn(R, &Config, &mut Vec<u8>) -> anyhow::Result<()> + Sync,
{
let level = writer.block_level();
run_parallel(
records,
policy,
weight,
cfg,
writer,
render,
|bytes: Vec<u8>| match level {
Some(level) => crate::io::fastq::encode_blocks(level, &bytes),
None => Ok(bytes),
},
|writer, bytes: &Vec<u8>| writer.write_all(bytes),
counters,
)
}
pub(crate) fn render_pool_size(cfg: &Config) -> usize {
if cfg.render_workers >= 1 {
cfg.render_workers
} else {
cfg.threads.max(1)
}
}
struct FirstError<E> {
slot: Mutex<Option<E>>,
}
impl<E> FirstError<E> {
fn new() -> Self {
Self {
slot: Mutex::new(None),
}
}
fn record(&self, error: E, aborted: &AtomicBool) {
aborted.store(true, Ordering::Relaxed);
let mut slot = self.slot.lock().unwrap();
if slot.is_none() {
*slot = Some(error);
}
}
fn take(&self) -> Option<E> {
self.slot.lock().unwrap().take()
}
}
struct ReorderWindow {
written: Mutex<usize>,
advanced: Condvar,
size: usize,
}
impl ReorderWindow {
fn new(size: usize) -> Self {
Self {
written: Mutex::new(0),
advanced: Condvar::new(),
size,
}
}
fn wait_for(&self, idx: usize, aborted: &AtomicBool) {
let mut written = self.written.lock().unwrap();
while idx >= *written + self.size && !aborted.load(Ordering::Relaxed) {
written = self.advanced.wait(written).unwrap();
}
}
fn advance(&self, written: usize) {
*self.written.lock().unwrap() = written;
self.advanced.notify_all();
}
fn release(&self) {
let _written = self.written.lock().unwrap();
self.advanced.notify_all();
}
}
struct FuseOnError<'a, I> {
inner: I,
done: bool,
aborted: &'a AtomicBool,
}
impl<I, R> Iterator for FuseOnError<'_, I>
where
I: Iterator<Item = anyhow::Result<R>>,
{
type Item = anyhow::Result<R>;
fn next(&mut self) -> Option<Self::Item> {
if self.done || self.aborted.load(Ordering::Relaxed) {
return None;
}
let item = self.inner.next()?;
self.done = item.is_err();
Some(item)
}
}
#[allow(clippy::too_many_arguments)]
pub(crate) fn run_parallel<R, T, P, S, Weight, Render, Pack, WriteOne>(
records: impl Iterator<Item = anyhow::Result<R>> + Send,
policy: BatchPolicy,
weight: Weight,
cfg: &Config,
sink: &mut S,
render: Render,
pack: Pack,
write_one: WriteOne,
counters: &Counters,
) -> anyhow::Result<Stats>
where
R: Send,
T: Default + Send,
P: Send,
S: Send,
Weight: Fn(&R) -> usize + Sync,
Render: Fn(R, &Config, &mut T) -> anyhow::Result<()> + Sync,
Pack: Fn(T) -> std::io::Result<P> + Sync,
WriteOne: Fn(&mut S, &P) -> std::io::Result<()> + Send,
{
let render_workers = render_pool_size(cfg);
let pool = rayon::ThreadPoolBuilder::new()
.num_threads(render_workers)
.build()?;
let queue = (render_workers * policy.queue_per_worker).max(2);
let (tx, rx) = std::sync::mpsc::sync_channel::<(usize, P)>(queue);
let ordered = cfg.ordered;
let aborted = AtomicBool::new(false);
let render_err: FirstError<anyhow::Error> = FirstError::new();
let write_err: FirstError<std::io::Error> = FirstError::new();
let window = ReorderWindow::new(queue + render_workers);
let aborted_ref = &aborted;
let window_ref = &window;
let records = FuseOnError {
inner: records,
done: false,
aborted: aborted_ref,
};
std::thread::scope(|s| {
let write_err = &write_err;
s.spawn(move || {
let mut next = 0usize;
let mut pending: BTreeMap<usize, P> = BTreeMap::new();
let mut errored = false;
let mut write_batch = |batch: &P| -> bool {
if let Err(e) = write_one(sink, batch) {
write_err.record(e, aborted_ref);
window_ref.release();
return false;
}
true
};
for (idx, batch) in rx.iter() {
if errored {
continue;
}
if ordered {
pending.insert(idx, batch);
let written = next;
while let Some(batch) = pending.remove(&next) {
if !write_batch(&batch) {
errored = true;
break;
}
next += 1;
}
if next > written {
window_ref.advance(next);
}
} else if !write_batch(&batch) {
errored = true;
}
}
});
pool.install(|| {
let weight_of = |rec: &anyhow::Result<R>| rec.as_ref().map_or(0, &weight);
let mut batches = Batches::new(records, weight_of, policy);
let mut handed_out = 0usize;
let batches = std::iter::from_fn(move || {
if ordered {
window_ref.wait_for(handed_out, aborted_ref);
}
let batch = batches.next()?;
handed_out += 1;
Some((handed_out - 1, batch))
});
let render_batch = |(idx, batch): (usize, Vec<anyhow::Result<R>>)| {
let mut out = T::default();
let mut input_reads = 0u64;
let mut input_bases = 0u64;
for rec in batch {
if aborted.load(Ordering::Relaxed) {
break;
}
let rec = match rec {
Ok(r) => r,
Err(e) => {
render_err.record(e, &aborted);
break;
},
};
input_reads += 1;
input_bases += weight(&rec) as u64;
if let Err(e) = render(rec, cfg, &mut out) {
render_err.record(e, &aborted);
break;
}
}
if aborted.load(Ordering::Relaxed) {
window.release();
}
counters
.input_reads
.fetch_add(input_reads, Ordering::Relaxed);
counters
.input_bases
.fetch_add(input_bases, Ordering::Relaxed);
let packed = match pack(out) {
Ok(packed) => packed,
Err(e) => {
render_err.record(e.into(), &aborted);
window.release();
return;
},
};
if tx.send((idx, packed)).is_err() {
aborted.store(true, Ordering::Relaxed);
window.release();
}
};
batches.par_bridge().for_each(render_batch);
});
drop(tx);
});
if let Some(e) = render_err.take() {
return Err(e);
}
if let Some(e) = write_err.take() {
return Err(e.into());
}
Ok(counters.snapshot())
}
#[derive(Default)]
pub struct Counters {
pub(crate) tagged_fastq: AtomicBool,
pub input_reads: AtomicU64,
pub output_reads: AtomicU64,
pub bytes_read: AtomicU64,
pub input_bases: AtomicU64,
pub output_bases: AtomicU64,
pub malformed_tag_reads: AtomicU64,
pub malformed_mod_reads: AtomicU64,
pub undo_tags_dropped_reads: AtomicU64,
pub footprint_tags_dropped_reads: AtomicU64,
pub barcode_tag_malformed_reads: AtomicU64,
pub barcode_tag_unverified_reads: AtomicU64,
pub tag_filtered_reads: AtomicU64,
pub(crate) rejects: OnceLock<reject::Rejects>,
pub reads_with_output: AtomicU64,
pub reads_trimmed_to_nothing: AtomicU64,
pub reads_all_filtered: AtomicU64,
pub segments_dropped_short: AtomicU64,
pub segments_dropped_long: AtomicU64,
pub segments_dropped_low_qual: AtomicU64,
pub segments_dropped_high_qual: AtomicU64,
pub segments_dropped_expected_errors: AtomicU64,
pub segments_dropped_gc: AtomicU64,
}
impl Counters {
pub(crate) fn wants_rejects(&self) -> bool {
self.rejects.get().is_some()
}
pub(crate) fn reject(&self, item: reject::RejectItem) -> anyhow::Result<()> {
match self.rejects.get() {
Some(rejects) => rejects.send(item),
None => Ok(()),
}
}
pub fn record_segment_drop(&self, reason: DropReason) {
let counter = match reason {
DropReason::TooShort => &self.segments_dropped_short,
DropReason::TooLong => &self.segments_dropped_long,
DropReason::LowQuality => &self.segments_dropped_low_qual,
DropReason::HighQuality => &self.segments_dropped_high_qual,
DropReason::ExpectedErrors => &self.segments_dropped_expected_errors,
DropReason::Gc => &self.segments_dropped_gc,
};
counter.fetch_add(1, Ordering::Relaxed);
}
pub fn snapshot(&self) -> Stats {
let input_reads = self.input_reads.load(Ordering::Relaxed);
let reads_with_output = self.reads_with_output.load(Ordering::Relaxed);
let reads_trimmed_to_nothing = self.reads_trimmed_to_nothing.load(Ordering::Relaxed);
let reads_all_filtered = self.reads_all_filtered.load(Ordering::Relaxed);
let reads_tag_filtered = self.tag_filtered_reads.load(Ordering::Relaxed);
let segments_dropped_short = self.segments_dropped_short.load(Ordering::Relaxed);
let segments_dropped_long = self.segments_dropped_long.load(Ordering::Relaxed);
let segments_dropped_low_qual = self.segments_dropped_low_qual.load(Ordering::Relaxed);
let segments_dropped_high_qual = self.segments_dropped_high_qual.load(Ordering::Relaxed);
let segments_dropped_expected_errors = self
.segments_dropped_expected_errors
.load(Ordering::Relaxed);
let segments_dropped_gc = self.segments_dropped_gc.load(Ordering::Relaxed);
debug_assert_eq!(
reads_with_output + reads_trimmed_to_nothing + reads_all_filtered + reads_tag_filtered,
input_reads,
"Every input read must be exactly one of: tag filtered, produced output, \
trimmed to nothing, or had every segment filtered"
);
Stats {
input_reads,
output_reads: self.output_reads.load(Ordering::Relaxed),
malformed_mod_reads: self.malformed_mod_reads.load(Ordering::Relaxed),
undo_tags_dropped_reads: self.undo_tags_dropped_reads.load(Ordering::Relaxed),
footprint_tags_dropped_reads: self.footprint_tags_dropped_reads.load(Ordering::Relaxed),
barcode_tag_malformed_reads: self.barcode_tag_malformed_reads.load(Ordering::Relaxed),
barcode_tag_unverified_reads: self.barcode_tag_unverified_reads.load(Ordering::Relaxed),
input_bases: self.input_bases.load(Ordering::Relaxed),
output_bases: self.output_bases.load(Ordering::Relaxed),
malformed_tag_reads: self.malformed_tag_reads.load(Ordering::Relaxed),
reads_with_output,
reads_trimmed_to_nothing,
reads_all_filtered,
reads_tag_filtered,
segments_dropped_short,
segments_dropped_long,
segments_dropped_low_qual,
segments_dropped_high_qual,
segments_dropped_expected_errors,
segments_dropped_gc,
}
}
}
pub(crate) fn read_span(name: &[u8]) -> tracing::Span {
if tracing::enabled!(tracing::Level::TRACE) {
tracing::trace_span!("read", name = %String::from_utf8_lossy(name))
} else {
tracing::Span::none()
}
}
pub(crate) fn process_read_segments<Rn, Rj>(
produced: &[(usize, usize)],
seq: &[u8],
qual: &[u8],
filter_cfg: &FilterConfig,
counters: &Counters,
mut render: Rn,
mut reject: Rj,
) -> anyhow::Result<()>
where
Rn: FnMut(usize, usize, usize, usize) -> anyhow::Result<()>,
Rj: FnMut(Rejection) -> anyhow::Result<()>,
{
let total = produced.len();
let mut survived = 0usize;
for (idx, &(s, e)) in produced.iter().enumerate() {
if let Some(reason) = crate::filter::check(&seq[s..e], &qual[s..e], filter_cfg) {
tracing::trace!(
segment = idx + 1,
of = total,
start = s,
end = e,
len = e - s,
reason = reason.label(),
"Segment dropped"
);
counters.record_segment_drop(reason);
reject(Rejection::Segment {
idx,
total,
start: s,
end: e,
reason,
})?;
continue;
}
tracing::trace!(
segment = idx + 1,
of = total,
start = s,
end = e,
len = e - s,
"Segment kept"
);
render(idx, total, s, e)?;
counters.output_reads.fetch_add(1, Ordering::Relaxed);
counters
.output_bases
.fetch_add((e - s) as u64, Ordering::Relaxed);
survived += 1;
}
if produced.is_empty() {
tracing::trace!("Read produced no segments");
counters
.reads_trimmed_to_nothing
.fetch_add(1, Ordering::Relaxed);
reject(Rejection::Whole)?;
} else if survived == 0 {
tracing::trace!(produced = total, "Every segment filtered");
counters.reads_all_filtered.fetch_add(1, Ordering::Relaxed);
} else {
counters.reads_with_output.fetch_add(1, Ordering::Relaxed);
}
Ok(())
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum Rejection {
Segment {
idx: usize,
total: usize,
start: usize,
end: usize,
reason: DropReason,
},
Whole,
}
#[derive(Debug, Default, Clone, Copy)]
pub struct Stats {
pub input_reads: u64,
pub output_reads: u64,
pub input_bases: u64,
pub output_bases: u64,
pub malformed_tag_reads: u64,
pub malformed_mod_reads: u64,
pub undo_tags_dropped_reads: u64,
pub footprint_tags_dropped_reads: u64,
pub barcode_tag_malformed_reads: u64,
pub barcode_tag_unverified_reads: u64,
pub reads_with_output: u64,
pub reads_trimmed_to_nothing: u64,
pub reads_all_filtered: u64,
pub reads_tag_filtered: u64,
pub segments_dropped_short: u64,
pub segments_dropped_long: u64,
pub segments_dropped_low_qual: u64,
pub segments_dropped_high_qual: u64,
pub segments_dropped_expected_errors: u64,
pub segments_dropped_gc: u64,
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn batches_stop_at_weight_or_record_limit() {
let by_weight: Vec<Vec<usize>> = Batches::new(
vec![800_000usize; 5].into_iter(),
|n: &usize| *n,
FASTQ_BATCH,
)
.collect();
assert_eq!(by_weight.iter().map(Vec::len).collect::<Vec<_>>(), [3, 2]);
let bam: Vec<Vec<usize>> =
Batches::new(vec![1usize; 65].into_iter(), |n: &usize| *n, BAM_BATCH).collect();
assert_eq!(
bam.iter().map(Vec::len).collect::<Vec<_>>(),
[16, 16, 16, 16, 1]
);
}
#[test]
fn three_way_read_counters_hold_the_invariant() {
let counters = Counters::default();
counters.input_reads.fetch_add(1, Ordering::Relaxed);
counters.output_reads.fetch_add(2, Ordering::Relaxed);
counters.reads_with_output.fetch_add(1, Ordering::Relaxed);
counters.input_reads.fetch_add(1, Ordering::Relaxed);
counters.record_segment_drop(DropReason::TooShort);
counters.record_segment_drop(DropReason::TooShort);
counters.reads_all_filtered.fetch_add(1, Ordering::Relaxed);
counters.input_reads.fetch_add(1, Ordering::Relaxed);
counters
.reads_trimmed_to_nothing
.fetch_add(1, Ordering::Relaxed);
let stats = counters.snapshot();
assert_eq!(stats.input_reads, 3);
assert_eq!(stats.output_reads, 2);
assert_eq!(
stats.reads_all_filtered, 1,
"Read b produced segments, but every one was filtered"
);
assert_eq!(
stats.reads_trimmed_to_nothing, 1,
"Read c produced no segments"
);
assert_eq!(counters.reads_with_output.load(Ordering::Relaxed), 1);
assert_eq!(
counters.reads_with_output.load(Ordering::Relaxed)
+ stats.reads_trimmed_to_nothing
+ stats.reads_all_filtered,
stats.input_reads
);
assert_eq!(stats.segments_dropped_short, 2);
assert_eq!(stats.segments_dropped_long, 0);
assert_eq!(stats.segments_dropped_low_qual, 0);
assert_eq!(stats.segments_dropped_high_qual, 0);
assert_eq!(stats.segments_dropped_gc, 0);
}
#[test]
fn process_read_segments_dispatches_and_counts_all_three_outcomes() {
let filter_cfg = FilterConfig {
min_length: 3,
max_length: usize::MAX,
min_qual: 0.0,
max_qual: 1000.0,
max_expected_errors: None,
min_gc: None,
max_gc: None,
qual_mode: crate::qual::QualMode::Mean,
};
{
let counters = Counters::default();
let mut calls: Vec<(usize, usize, usize, usize)> = Vec::new();
process_read_segments(
&[],
b"",
b"",
&filter_cfg,
&counters,
|idx, total, s, e| {
calls.push((idx, total, s, e));
Ok(())
},
|_| Ok(()),
)
.unwrap();
assert!(calls.is_empty());
assert_eq!(counters.reads_trimmed_to_nothing.load(Ordering::Relaxed), 1);
assert_eq!(counters.reads_all_filtered.load(Ordering::Relaxed), 0);
assert_eq!(counters.reads_with_output.load(Ordering::Relaxed), 0);
assert_eq!(counters.segments_dropped_short.load(Ordering::Relaxed), 0);
}
{
let counters = Counters::default();
let seq = b"AA";
let qual = b"II";
let mut calls: Vec<(usize, usize, usize, usize)> = Vec::new();
process_read_segments(
&[(0, 2)],
seq,
qual,
&filter_cfg,
&counters,
|idx, total, s, e| {
calls.push((idx, total, s, e));
Ok(())
},
|_| Ok(()),
)
.unwrap();
assert!(calls.is_empty());
assert_eq!(counters.reads_trimmed_to_nothing.load(Ordering::Relaxed), 0);
assert_eq!(counters.reads_all_filtered.load(Ordering::Relaxed), 1);
assert_eq!(counters.reads_with_output.load(Ordering::Relaxed), 0);
assert_eq!(counters.segments_dropped_short.load(Ordering::Relaxed), 1);
}
{
let counters = Counters::default();
let seq = b"AAAAAA";
let qual = b"IIIIII";
let mut calls: Vec<(usize, usize, usize, usize)> = Vec::new();
process_read_segments(
&[(0, 3), (3, 6)],
seq,
qual,
&filter_cfg,
&counters,
|idx, total, s, e| {
calls.push((idx, total, s, e));
Ok(())
},
|_| Ok(()),
)
.unwrap();
assert_eq!(calls, vec![(0, 2, 0, 3), (1, 2, 3, 6)]);
assert_eq!(counters.reads_trimmed_to_nothing.load(Ordering::Relaxed), 0);
assert_eq!(counters.reads_all_filtered.load(Ordering::Relaxed), 0);
assert_eq!(counters.reads_with_output.load(Ordering::Relaxed), 1);
assert_eq!(counters.output_reads.load(Ordering::Relaxed), 2);
assert_eq!(counters.output_bases.load(Ordering::Relaxed), 6);
}
}
fn driver_cfg(threads: usize, ordered: bool) -> Config {
let path = std::path::Path::new("/dev/null");
let mut cfg = crate::cli::config_for_test_threads(path, path, 0, 0, threads);
cfg.ordered = ordered;
cfg
}
fn run_driver(ordered: bool) -> Vec<usize> {
let cfg = driver_cfg(4, ordered);
let mut sink: Vec<usize> = Vec::new();
let counters = Counters::default();
run_parallel(
(0..200usize).map(anyhow::Ok),
BatchPolicy {
target_weight: 1,
max_items: 1,
queue_per_worker: 1,
},
|_: &usize| 1,
&cfg,
&mut sink,
|n, _cfg, out: &mut Vec<usize>| {
if n % 2 == 1 {
std::thread::sleep(std::time::Duration::from_micros(200));
}
counters.reads_with_output.fetch_add(1, Ordering::Relaxed);
out.push(n);
Ok(())
},
Ok,
|sink, batch: &Vec<usize>| {
sink.extend_from_slice(batch);
Ok(())
},
&counters,
)
.unwrap();
sink
}
#[test]
fn ordered_driver_bounds_read_ahead_behind_a_slow_batch() {
use std::sync::atomic::AtomicUsize;
use std::time::Duration;
let cfg = driver_cfg(4, true);
let consumed = AtomicUsize::new(0);
let (ready_tx, ready_rx) = std::sync::mpsc::channel();
let (release_tx, release_rx) = std::sync::mpsc::channel();
let release_rx = Mutex::new(release_rx);
let mut output = Vec::new();
let counters = Counters::default();
std::thread::scope(|scope| {
let consumed_ref = &consumed;
let observed = scope.spawn(move || {
for _ in 0..7 {
ready_rx.recv_timeout(Duration::from_secs(5)).unwrap();
}
std::thread::sleep(Duration::from_millis(20));
let read_ahead = consumed_ref.load(Ordering::Relaxed);
release_tx.send(()).unwrap();
read_ahead
});
run_parallel(
(0..1000usize).map(|n| {
consumed.fetch_add(1, Ordering::Relaxed);
Ok(n)
}),
BatchPolicy {
target_weight: 1,
max_items: 1,
queue_per_worker: 1,
},
|_| 1,
&cfg,
&mut output,
|n, _, out: &mut Vec<usize>| {
if n == 0 {
release_rx
.lock()
.unwrap()
.recv_timeout(Duration::from_secs(5))
.unwrap();
} else if n < 8 {
ready_tx.send(()).unwrap();
}
counters.reads_with_output.fetch_add(1, Ordering::Relaxed);
out.push(n);
Ok(())
},
Ok,
|out, batch: &Vec<usize>| {
out.extend_from_slice(batch);
Ok(())
},
&counters,
)
.unwrap();
assert_eq!(observed.join().unwrap(), 8);
});
assert_eq!(output, (0..1000).collect::<Vec<_>>());
}
#[test]
fn ordered_driver_propagates_write_errors() {
let cfg = driver_cfg(4, true);
let error = run_parallel(
(0..1000usize).map(Ok),
BatchPolicy {
target_weight: 1,
max_items: 1,
queue_per_worker: 1,
},
|_| 1,
&cfg,
&mut (),
|n, _, out: &mut Vec<usize>| {
out.push(n);
Ok(())
},
Ok,
|_, _: &Vec<usize>| Err(std::io::Error::other("sink failed")),
&Counters::default(),
)
.unwrap_err();
assert_eq!(error.to_string(), "sink failed");
}
#[test]
fn ordered_driver_ends_on_a_pack_error() {
let cfg = driver_cfg(4, true);
let error = run_parallel(
(0..1000usize).map(Ok),
BatchPolicy {
target_weight: 1,
max_items: 1,
queue_per_worker: 1,
},
|_| 1,
&cfg,
&mut Vec::new(),
|n, _, out: &mut Vec<usize>| {
out.push(n);
Ok(())
},
|batch: Vec<usize>| {
if batch == [3] {
return Err(std::io::Error::other("pack failed"));
}
Ok(batch)
},
|out: &mut Vec<usize>, batch: &Vec<usize>| {
out.extend_from_slice(batch);
Ok(())
},
&Counters::default(),
)
.unwrap_err();
assert_eq!(error.to_string(), "pack failed");
}
#[test]
fn ordered_driver_writes_in_input_order() {
let out = run_driver(true);
assert_eq!(out, (0..200).collect::<Vec<_>>());
}
#[test]
fn unordered_driver_writes_every_item_once() {
let mut out = run_driver(false);
out.sort_unstable();
assert_eq!(out, (0..200).collect::<Vec<_>>());
}
#[test]
fn driver_stops_polling_the_source_after_its_first_error() {
struct PoisonAfterError {
n: usize,
yielded_error: bool,
}
impl Iterator for PoisonAfterError {
type Item = anyhow::Result<usize>;
fn next(&mut self) -> Option<Self::Item> {
assert!(!self.yielded_error, "Source polled after it returned Err");
if self.n == 50 {
self.yielded_error = true;
return Some(Err(anyhow::anyhow!("incomplete stream")));
}
self.n += 1;
Some(Ok(self.n))
}
}
let cfg = driver_cfg(4, false);
let mut sink: Vec<usize> = Vec::new();
let counters = Counters::default();
let res = run_parallel(
PoisonAfterError {
n: 0,
yielded_error: false,
},
FASTQ_BATCH,
|_: &usize| 1,
&cfg,
&mut sink,
|n, _cfg, out: &mut Vec<usize>| {
out.push(n);
Ok(())
},
Ok,
|sink, batch: &Vec<usize>| {
sink.extend_from_slice(batch);
Ok(())
},
&counters,
);
assert_eq!(res.unwrap_err().to_string(), "incomplete stream");
}
#[test]
fn driver_stops_rendering_after_the_first_render_error() {
use std::sync::atomic::AtomicUsize;
let cfg = driver_cfg(2, false);
let mut sink: Vec<usize> = Vec::new();
let counters = Counters::default();
let rendered = AtomicUsize::new(0);
let res = run_parallel(
(0..100_000usize).map(anyhow::Ok),
BatchPolicy {
target_weight: 1,
max_items: 1,
queue_per_worker: 1,
},
|_: &usize| 1,
&cfg,
&mut sink,
|n, _cfg, out: &mut Vec<usize>| {
rendered.fetch_add(1, Ordering::Relaxed);
if n == 10 {
anyhow::bail!("record 10 is malformed");
}
out.push(n);
Ok(())
},
Ok,
|sink, batch: &Vec<usize>| {
sink.extend_from_slice(batch);
Ok(())
},
&counters,
);
assert!(res.is_err());
assert!(
rendered.load(Ordering::Relaxed) < 1_000,
"Rendering continued long after the first error: {} records",
rendered.load(Ordering::Relaxed)
);
}
}