165 lines
6.8 KiB
Rust
165 lines
6.8 KiB
Rust
//! Throwaway benchmark of the de Bruijn graph on a real kmer set:
|
|||
|
|
//! `graph_bench <unitigs.bin> <k> [repeat]` builds `GraphDeBruijn` from the
|
||
|
|
//! canonical kmers of an existing layer's unitigs (same call sequence as
|
||
|
|
//! `write_graph_as_unitigs`) and times each phase.
|
||
|
|
use std::path::PathBuf;
|
||
|
|
use std::time::Instant;
|
||
|
|
|
||
|
|
use obidebruinj::GraphDeBruijn;
|
||
|
|
use obikseq::Sequence;
|
||
|
|
use obiskio::CanonicalKmerIter;
|
||
|
|
use rayon::prelude::*;
|
||
|
|
use std::collections::HashSet;
|
||
|
|
|
||
|
|
fn main() {
|
||
|
|
let args: Vec<String> = std::env::args().collect();
|
||
|
|
let path = PathBuf::from(&args[1]);
|
||
|
|
let k: usize = args[2].parse().unwrap();
|
||
|
|
let repeat: usize = args.get(3).map_or(1, |s| s.parse().unwrap());
|
||
|
|
obikseq::set_k(k);
|
||
|
|
obikseq::set_m(11);
|
||
|
|
let kmers: Vec<_> = if let Ok(n) = std::env::var("SYNTH") {
|
||
|
|
// synthetic reads: random genome, reads on both strands, 1 % substitutions
|
||
|
|
let n: usize = n.parse().unwrap();
|
||
|
|
let mut st = 0x9E3779B97F4A7C15u64;
|
||
|
|
let mut rnd = move || {
|
||
|
|
st ^= st << 13;
|
||
|
|
st ^= st >> 7;
|
||
|
|
st ^= st << 17;
|
||
|
|
st
|
||
|
|
};
|
||
|
|
let genome: Vec<u8> = (0..n).map(|_| b"ACGT"[(rnd() % 4) as usize]).collect();
|
||
|
|
let mut set = std::collections::BTreeSet::new();
|
||
|
|
for _ in 0..(n / 50) {
|
||
|
|
let start = (rnd() as usize) % (n - 100);
|
||
|
|
let mut read: Vec<u8> = genome[start..start + 100].to_vec();
|
||
|
|
for b in read.iter_mut() {
|
||
|
|
if rnd() % 100 == 0 {
|
||
|
|
*b = b"ACGT"[(rnd() % 4) as usize];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
for w in read.windows(k) {
|
||
|
|
set.insert(obikseq::Kmer::from_ascii(w).unwrap().canonical());
|
||
|
|
}
|
||
|
|
}
|
||
|
|
set.into_iter().collect()
|
||
|
|
} else {
|
||
|
|
CanonicalKmerIter::new(&path).unwrap().collect()
|
||
|
|
};
|
||
|
|
eprintln!("{} kmers", kmers.len());
|
||
|
|
// Independent count of maximal unitigs: nodes − mutually-unique links
|
||
|
|
// (cycles ignored), computed with a plain HashSet — no use of GraphDeBruijn.
|
||
|
|
if std::env::var("IDEAL").is_ok() {
|
||
|
|
let set: HashSet<u64> = kmers.iter().map(|c| c.raw()).collect();
|
||
|
|
let outs = |a: obikseq::Kmer| -> Vec<obikseq::Kmer> {
|
||
|
|
(0..4u8)
|
||
|
|
.map(|x| a.push_right(x))
|
||
|
|
.filter(|b| set.contains(&b.canonical().raw()))
|
||
|
|
.collect()
|
||
|
|
};
|
||
|
|
let links: usize = kmers
|
||
|
|
.par_iter()
|
||
|
|
.map(|c| {
|
||
|
|
let mut n = 0usize;
|
||
|
|
for o in [c.into_kmer(), c.into_kmer().revcomp()] {
|
||
|
|
let ob = outs(o);
|
||
|
|
if ob.len() == 1 {
|
||
|
|
let b = ob[0];
|
||
|
|
// in-neighbours of b = revcomp of out-neighbours of revcomp(b)
|
||
|
|
if outs(b.revcomp()).len() == 1 {
|
||
|
|
// count each undirected link once: only from the orientation
|
||
|
|
// whose canonical raw is the smaller end (ties: both seen once per orientation)
|
||
|
|
let (ca, cb) = (o.canonical().raw(), b.canonical().raw());
|
||
|
|
if ca < cb || (ca == cb && o.raw() <= b.raw()) {
|
||
|
|
n += 1;
|
||
|
|
} else if ca > cb {
|
||
|
|
// seen from the other end too: skip
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
n
|
||
|
|
})
|
||
|
|
.sum();
|
||
|
|
eprintln!("IDEAL: nodes={} links={} -> maximal unitigs ≈ {}", kmers.len(), links, kmers.len() - links);
|
||
|
|
}
|
||
|
|
if std::env::var("IDEALDUMP").is_ok() {
|
||
|
|
let set: HashSet<u64> = kmers.iter().map(|c| c.raw()).collect();
|
||
|
|
let outs = |a: obikseq::Kmer| -> Vec<obikseq::Kmer> {
|
||
|
|
(0..4u8).map(|x| a.push_right(x)).filter(|b| set.contains(&b.canonical().raw())).collect()
|
||
|
|
};
|
||
|
|
// oriented kmer a has a mutual predecessor p iff ins(a)=={p} and outs(p)=={a}
|
||
|
|
let pred = |a: obikseq::Kmer| -> Option<obikseq::Kmer> {
|
||
|
|
let ins: Vec<obikseq::Kmer> = outs(a.revcomp()).into_iter().map(|b| b.revcomp()).collect();
|
||
|
|
if ins.len() == 1 && outs(ins[0]).len() == 1 { Some(ins[0]) } else { None }
|
||
|
|
};
|
||
|
|
let mut seen_chains = std::collections::BTreeSet::new();
|
||
|
|
for c in &kmers {
|
||
|
|
for o in [c.into_kmer(), c.into_kmer().revcomp()] {
|
||
|
|
if pred(o).is_some() { continue; }
|
||
|
|
let mut text: Vec<u8> = (0..k).map(|i| b"ACGT"[o.nucleotide(i) as usize]).collect();
|
||
|
|
let mut cur = o;
|
||
|
|
loop {
|
||
|
|
let ob = outs(cur);
|
||
|
|
if ob.len() != 1 { break; }
|
||
|
|
let b = ob[0];
|
||
|
|
if pred(b).is_none() { break; }
|
||
|
|
text.push(b"ACGT"[b.nucleotide(k - 1) as usize]);
|
||
|
|
cur = b;
|
||
|
|
}
|
||
|
|
let s = String::from_utf8(text).unwrap();
|
||
|
|
let rc: String = s.bytes().rev().map(|c| match c { b'A' => 'T', b'C' => 'G', b'G' => 'C', _ => 'A' }).collect();
|
||
|
|
seen_chains.insert(if s <= rc { s } else { rc });
|
||
|
|
}
|
||
|
|
}
|
||
|
|
for u in &seen_chains { println!("IDEALUNITIG {} {}", u.len(), u); }
|
||
|
|
}
|
||
|
|
for r in 0..repeat {
|
||
|
|
let t = Instant::now();
|
||
|
|
let mut g = GraphDeBruijn::new();
|
||
|
|
for &kmer in &kmers {
|
||
|
|
g.push(kmer);
|
||
|
|
}
|
||
|
|
let t_push = t.elapsed();
|
||
|
|
|
||
|
|
let t = Instant::now();
|
||
|
|
g.compute_degrees_and_mark_starts();
|
||
|
|
let t_deg = t.elapsed();
|
||
|
|
|
||
|
|
let t = Instant::now();
|
||
|
|
let n_unitigs = std::sync::atomic::AtomicUsize::new(0);
|
||
|
|
let n_nuc = std::sync::atomic::AtomicUsize::new(0);
|
||
|
|
let dump = std::env::var("DUMP").is_ok();
|
||
|
|
let seqs = std::sync::Mutex::new(Vec::<String>::new());
|
||
|
|
g.for_each_unitig(|it| {
|
||
|
|
let mut n = 0usize;
|
||
|
|
let mut text = String::new();
|
||
|
|
for nuc in it {
|
||
|
|
n += 1;
|
||
|
|
if dump {
|
||
|
|
text.push(b"ACGT"[nuc as usize] as char);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if dump {
|
||
|
|
seqs.lock().unwrap().push(text);
|
||
|
|
}
|
||
|
|
n_unitigs.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
|
||
|
|
n_nuc.fetch_add(n, std::sync::atomic::Ordering::Relaxed);
|
||
|
|
});
|
||
|
|
let t_walk = t.elapsed();
|
||
|
|
if dump {
|
||
|
|
let mut v = seqs.lock().unwrap().clone();
|
||
|
|
v.sort();
|
||
|
|
for u in v { println!("UNITIG {} {}", u.len(), u); }
|
||
|
|
}
|
||
|
|
println!(
|
||
|
|
"run {r}: nodes={} push={:.2?} degrees={:.2?} unitigs={:.2?} -> {} unitigs, {} nucleotides",
|
||
|
|
g.len(),
|
||
|
|
t_push,
|
||
|
|
t_deg,
|
||
|
|
t_walk,
|
||
|
|
n_unitigs.load(std::sync::atomic::Ordering::Relaxed),
|
||
|
|
n_nuc.load(std::sync::atomic::Ordering::Relaxed)
|
||
|
|
);
|
||
|
|
}
|
||
|
|
}
|