Files
obikmer/src/obikindexer/examples/graph_bench.rs
T
Eric Coissac 8468319a63 Refactor unitig detection and graph traversal logic
Introduce new hashing mechanisms and support for directional unitig checks. Fix fragmentation issues and improve performance metrics through optimized graph construction and new benchmarking utilities.
2026-10-15 12:19:24 +02:00

166 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)
);
}
}