Files
obikmer/src/obikindexer/examples/graph_bench.rs
T

165 lines
6.8 KiB
Rust
Raw Normal View History

//! 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)
);
}
}