diff --git a/DevDocMD/implementation/mphf_batch_queries.md b/DevDocMD/implementation/mphf_batch_queries.md index c5311d51..6554f115 100644 --- a/DevDocMD/implementation/mphf_batch_queries.md +++ b/DevDocMD/implementation/mphf_batch_queries.md @@ -355,3 +355,13 @@ Apple M3 Max (aarch64, 16 cores, 128 GB), on AC power; absolute times are not th - The DRAM-latency gain of MPHF prefetch itself, the original motivation (§1–§6): the measured MPHF share of the profiles is ≈ 1 % (§11), and the layers here are 4× to 1 000× smaller than production ones. The −5 % seen on the first query change came mostly from batching per layer (probably fewer shared `Arc` clones, §11), not from prefetch. A prod-scale benchmark (§6) remains to be run on the production machine. - Speed-ups on the 192-core / 1 TB production machine, on `merge`, `filter`, `select` and `phylo` at the 180-genome scale (the 91-genome index could only be used for `query`, `dump`, `phylo --distance jaccard`, `utils --stats`; `filter`/`select`/`merge` refused its pre-`state` `index.meta` until it was patched in the clone). - The size of the Primula index composition (§ calculated: ≈ half evidence from 35–40 G kmers × 4 bytes; not measured). + +## 21. Dead code removed (2026-10-15) + +The items listed as unused in §4 were removed after Serena's `safe_delete_symbol` and the compiler confirmed no reference: `MphfLayer::find_strict`; the single-kmer `hash` chain (`MphfLayer::hash`, `TypedLayer::hash`, `KmerLayer::hash`, `IndexCache::hash`); `IndexCache::find`; the uncompiled `obikmerge/src/merge_layer/` directory (689 lines; `lib.rs` only declares `merge` and `partition_merge`); and `xxhash-rust` from `obidebruinj/Cargo.toml` (it still serves `obikseq`, `obifastwrite` and `obiksession`). + +Side effect: `find_strict` was the only reader of the `unitigs` handle that `Hybrid` layers opened, so that field (and the extra `.idx` map and mmap per Hybrid layer) was dropped too. `find` on a Hybrid layer was already a fingerprint check; the exact evidence stays on disk (it gives the slot count and is what `convert` works from) but no API consults it any more. Restoring an exact lookup for Hybrid layers means re-adding `find_strict` and that field. + +`ahash` in `obidebruinj/Cargo.toml` is not referenced by any source file of the crate either (not removed: not asked). + +Checks after the removal: `cargo build --release` without warnings, `cargo test --workspace` 555 passed / 0 failed, `scripts/smoke_test_index.sh` PASS. diff --git a/src/Cargo.lock b/src/Cargo.lock index f26cec49..5dc76f63 100644 --- a/src/Cargo.lock +++ b/src/Cargo.lock @@ -1426,7 +1426,6 @@ dependencies = [ "obikseq", "rayon", "tracing", - "xxhash-rust", ] [[package]] diff --git a/src/obidebruinj/Cargo.toml b/src/obidebruinj/Cargo.toml index 301999a8..c4d1fdd1 100644 --- a/src/obidebruinj/Cargo.toml +++ b/src/obidebruinj/Cargo.toml @@ -10,7 +10,6 @@ ahash = "0.8" hashbrown = { version = "0.17", features = ["rayon"] } rayon = "1" crossbeam-channel = "0.5" -xxhash-rust = { version = "0.8.15", features = ["xxh3", "const_xxh3"] } tracing = "0.1" [features] diff --git a/src/obikidxcache/src/index_cache.rs b/src/obikidxcache/src/index_cache.rs index 8dcbfb71..0945dc5d 100644 --- a/src/obikidxcache/src/index_cache.rs +++ b/src/obikidxcache/src/index_cache.rs @@ -188,11 +188,6 @@ impl IndexCache { self.iter().flat_map(|l| l.iter_unitigs()) } - #[inline] - pub fn hash(&self, partition: usize, layer: usize, kmer: CanonicalKmer) -> Option { - Some(self.get_layer(partition, layer)?.hash(kmer)) - } - pub fn n_kmer(&self, partition: usize, layer: usize) -> Option { Some(self.get_layer(partition, layer)?.n()) } @@ -228,20 +223,6 @@ impl IndexCache { None } - /// Membership-checked lookup — routes `kmer` straight to its one - /// possible partition (`CanonicalKmer::partition`, the same - /// minimizer-hash rule every k-mer was scattered by when the index was - /// built) instead of scanning every cached partition: a k-mer can only - /// ever live in the partition it hashes to, so anywhere else is not - /// worth even asking. Uses `self.index().n_partitions()` — the index's - /// real total, not [`n_partition`](Self::n_partition) (this cache's own - /// count, which can be a subset — see [`new`](Self::new)). `None` if - /// that partition isn't cached or doesn't carry `kmer`. - pub fn find(&self, kmer: CanonicalKmer) -> Option<(usize, usize, usize)> { - let partition = kmer.partition(self.raw_index.n_partitions()); - self.find_in_partition(partition, kmer) - } - /// Parallel map-reduce over every cached `KmerLayer` (across every /// cached partition), bounded to `max_concurrent` layers scanned at /// once — a cap on how many layers are actively being mapped diff --git a/src/obikindex/src/layer/content_layer.rs b/src/obikindex/src/layer/content_layer.rs index 559d9f8f..610fcf36 100644 --- a/src/obikindex/src/layer/content_layer.rs +++ b/src/obikindex/src/layer/content_layer.rs @@ -297,15 +297,6 @@ impl KmerLayer { } } - /// Raw MPHF lookup: kmer → slot, no membership check. - pub fn hash(&self, kmer: CanonicalKmer) -> usize { - match self { - KmerLayer::Count { layer, .. } => layer.hash(kmer), - KmerLayer::Presence { layer, .. } => layer.hash(kmer), - KmerLayer::Empty { .. } => panic!("Layer::hash() called on an Empty layer"), - } - } - /// Iterate over all canonical kmers in the layer, in deterministic order. pub fn iter_kmers(&self) -> crate::layer::mphf_layer::KmerIter { match self { diff --git a/src/obikindex/src/layer/meta.rs b/src/obikindex/src/layer/meta.rs index 935ae45f..aa31015e 100644 --- a/src/obikindex/src/layer/meta.rs +++ b/src/obikindex/src/layer/meta.rs @@ -27,7 +27,7 @@ pub enum IndexMode { /// [`detect`](Self::detect)). Approx { b: u8, z: u8 }, /// Hybrid: both `fingerprint.bin` and `evidence.bin` + `unitigs.bin.idx`. - /// `find()` uses the fingerprint (O(1), approx); `find_strict()` uses exact evidence. + /// `find()` uses the fingerprint (O(1), approx); the exact evidence is kept alongside. Hybrid { b: u8, z: u8 }, } diff --git a/src/obikindex/src/layer/mphf_layer.rs b/src/obikindex/src/layer/mphf_layer.rs index 6d40a2db..e2bd2e89 100644 --- a/src/obikindex/src/layer/mphf_layer.rs +++ b/src/obikindex/src/layer/mphf_layer.rs @@ -51,17 +51,17 @@ enum LayerEvidence { Hybrid { evidence_path: PathBuf, fingerprint_path: PathBuf, - unitig_path: PathBuf, }, } -/// Resources actually opened (mmap). `Exact`/`Hybrid` carry their own -/// `unitigs` — needed to complete evidence verification, not shared with -/// `MphfLayer`'s own separate `unitigs` (used by `iter_kmers`/`Approx`'s -/// `find_strict` fallback, mode-independent). Yes, this means a layer's -/// `unitigs.bin` gets mmapped twice for Exact/Hybrid — deliberately not -/// optimised away here: avoiding that redundant open is the future cache -/// crate's job, not this base type's. +/// Resources actually opened (mmap). `Exact` carries its own `unitigs` — +/// needed to complete evidence verification, not shared with `MphfLayer`'s +/// own separate `unitigs` (used by `iter_kmers`, mode-independent). Yes, this +/// means an Exact layer's `unitigs.bin` gets mmapped twice (the `.idx` +/// offsets are mapped too, so both readers share the same pages) — +/// deliberately not optimised away here. `Hybrid` keeps its `evidence.bin` +/// open (it gives the slot count) but nothing verifies against it: lookups +/// use the fingerprint, as in `Approx`. enum OpenLayerEvidence { Exact { evidence: Evidence, @@ -73,7 +73,6 @@ enum OpenLayerEvidence { Hybrid { evidence: Evidence, fingerprint: FingerprintVec, - unitigs: Arc, }, } @@ -93,7 +92,6 @@ impl LayerEvidence { EvidenceKind::Hybrid => LayerEvidence::Hybrid { evidence_path: layer_dir.join(EVIDENCE_FILE), fingerprint_path: layer_dir.join(FINGERPRINT_FILE), - unitig_path: layer_dir.join(UNITIGS_FILE), }, }) } @@ -108,10 +106,9 @@ impl LayerEvidence { LayerEvidence::Approx { fingerprint_path } => OpenLayerEvidence::Approx { fingerprint: FingerprintVec::open(&fingerprint_path)?, }, - LayerEvidence::Hybrid { evidence_path, fingerprint_path, unitig_path } => OpenLayerEvidence::Hybrid { + LayerEvidence::Hybrid { evidence_path, fingerprint_path } => OpenLayerEvidence::Hybrid { evidence: Evidence::open(&evidence_path)?, fingerprint: FingerprintVec::open(&fingerprint_path)?, - unitigs: Arc::new(UnitigFileReader::open(&unitig_path)?), }, }) } @@ -151,16 +148,12 @@ impl EvidenceKind { /// Autonomous kmer → slot mapping for one layer. /// -/// Two query methods: -/// - [`find`](Self::find) — O(1), uses fingerprint (Approx/Hybrid) or exact evidence (Exact). -/// - [`find_strict`](Self::find_strict) — always exact; O(1) on Exact/Hybrid layers, -/// O(n) sequential scan on Approx layers. +/// Query: [`find`](Self::find) — O(1), uses the fingerprint (Approx/Hybrid) or +/// exact evidence (Exact). pub struct MphfLayer { - /// Mode-independent copy — used by `iter_kmers` (all modes) and - /// `find_strict`'s `Approx` fallback. `Exact`/`Hybrid` additionally - /// carry their own inside `OpenLayerEvidence` (see its doc comment for - /// why that's a second, deliberately unshared mmap of the same file, - /// not a bug). + /// Mode-independent copy — used by `iter_kmers` (all modes). `Exact` + /// additionally carries its own inside `OpenLayerEvidence` (see its doc + /// comment for why that's a second mmap of the same file, not a bug). unitigs: Arc, mphf: MphfOnly, @@ -192,7 +185,7 @@ impl MphfLayer { /// O(1) lookup — dispatches automatically: /// - Exact: evidence + `verify_canonical_kmer`, zero false positives. /// - Approx: fingerprint check, false-positive rate ≈ 1/2^b. - /// - Hybrid: fingerprint check (fast path), zero false positives via `find_strict`. + /// - Hybrid: fingerprint check, same as Approx (the exact evidence is kept on disk, not consulted). #[inline] pub fn find(&self, kmer: CanonicalKmer) -> Option { self.confirm(self.mphf.index(kmer), kmer) @@ -242,43 +235,6 @@ impl MphfLayer { }); } - /// Always-exact lookup — zero false positives regardless of mode. - /// - /// - Exact/Hybrid: O(1) via evidence + `verify_canonical_kmer`. - /// - Approx: O(n) sequential scan of `unitigs.bin` to confirm the kmer - /// that owns the slot, then exact comparison. - pub fn find_strict(&self, kmer: CanonicalKmer) -> Option { - let slot = self.mphf.index(kmer); - if slot >= self.n { - return None; - } - match &self.ev { - OpenLayerEvidence::Exact { evidence, unitigs } - | OpenLayerEvidence::Hybrid { evidence, unitigs, .. } => { - let (chunk_id, rank) = evidence.decode(slot); - if unitigs.verify_canonical_kmer(chunk_id as usize, rank as usize, kmer) { - Some(slot) - } else { - None - } - } - OpenLayerEvidence::Approx { .. } => { - // `self.unitigs` was opened via `UnitigFileReader::open`, which - // falls back to sequential mode automatically when no `.idx` - // sidecar exists — true for every Approx layer (`build_unitig_idx` - // is only ever called for Exact/Hybrid). Reusing it here avoids - // the second file-open + mmap + kmer-count scan a fresh - // `open_sequential` call would repeat on every call. - for (stored, _, _) in self.unitigs.iter_indexed_canonical_kmers() { - if self.mphf.index(stored) == slot { - return if stored == kmer { Some(slot) } else { None }; - } - } - None - } - } - } - /// Number of slots in the MPHF layer — equal to the number of stored k-mers. pub fn n(&self) -> usize { self.n @@ -294,16 +250,6 @@ impl MphfLayer { } } - /// Raw MPHF lookup: kmer → slot. - /// - /// Returns the slot assigned by the MPHF without performing any membership - /// check against the layer's evidence. The returned slot is only meaningful - /// when the kmer is actually present in the layer; callers that need an - /// existence test should use [`find`](Self::find) instead. - pub fn hash(&self, kmer: CanonicalKmer) -> usize { - self.mphf.index(kmer) - } - /// Batch raw MPHF lookup: kmers → slots. /// /// Returns a [`Vec`] of slots, one per input kmer, in the same order as the diff --git a/src/obikindex/src/layer/typed_layer.rs b/src/obikindex/src/layer/typed_layer.rs index 45fb0f09..a0bfce12 100644 --- a/src/obikindex/src/layer/typed_layer.rs +++ b/src/obikindex/src/layer/typed_layer.rs @@ -200,11 +200,6 @@ impl TypedLayer { self.kmerstore.n() } - /// Raw MPHF lookup: kmer → slot, no membership check. - pub fn hash(&self, kmer: CanonicalKmer) -> usize { - self.kmerstore.hash(kmer) - } - /// Batch raw MPHF lookup: kmers → slots, no membership check. pub fn hash_batch(&self, kmers: &[CanonicalKmer]) -> Vec { self.kmerstore.hash_batch(kmers) diff --git a/src/obikmerge/src/merge_layer/mod.rs b/src/obikmerge/src/merge_layer/mod.rs deleted file mode 100644 index f659327c..00000000 --- a/src/obikmerge/src/merge_layer/mod.rs +++ /dev/null @@ -1,595 +0,0 @@ -//! Merging a source partition's new layer into a destination partition: -//! de Bruijn graph union (pass 1) then column fill (pass 2). -//! -//! Submodules: [`src_layer`] (`SrcLayerData`, the opened-source-matrix -//! lookup used by pass 2 here and by `rebuild_layer`). The `merge_partition` -//! orchestration itself stays in this file — its ~400-line body is one -//! tightly threaded pipeline (shared `Arc`/`Mutex` state across pass 1, -//! builder setup, and pass 2), not a set of independently callable steps. - -use std::fs; -use std::io; -use std::path::{Path, PathBuf}; -use std::sync::{Arc, Mutex}; - -use obipipeline::{ - Pipeline, PipelineError, PipelineSender, SharedFlatFn, Stage, ThrottleGuard, WorkerPool, - make_sink, make_source, make_transform, throttle, -}; -use tracing::debug; - -use obicompactvec::{PersistentBitMatrixBuilder, PersistentCompactIntMatrixBuilder}; -use obikseq::CanonicalKmer; -use obikindex::layer::{IndexMode, TypedLayer, LayeredMap, MphfOnly}; -use obikindex::layer::utils::layer_dir; -use obiskio::UnitigFileReader; -use obikindex::{OKIError, OKIResult}; - -use obikindex::{ColBuilder, load_meta}; -use obikindexer::{build_graph, materialize_layer}; -use obikindex::KmerIndex; - -mod src_layer; - -pub use src_layer::SrcLayerData; - -// ── MergeMode ───────────────────────────────────────────────────────────────── - -#[derive(Debug, Clone, Copy, PartialEq, Eq)] -pub enum MergeMode { - Presence, - Count, -} - -// ── MatrixBuilder ───────────────────────────────────────────────────────────── -// -// Wraps whichever matrix builder `mode` calls for, so the merge pipeline never -// has to know the on-disk column naming (`col_NNNNNN.pbiv`/`.pciv`) or the -// matrix `meta.json` schema itself — both stay private to obicompactvec. -// `resume` reopens a matrix directory already closed by a previous builder -// session (an existing destination layer), continuing from its current -// `n_cols` instead of starting a fresh matrix at 0. - -enum MatrixBuilder { - Bit(PersistentBitMatrixBuilder), - Int(PersistentCompactIntMatrixBuilder), -} - -impl MatrixBuilder { - fn new(mode: MergeMode, n: usize, dir: &Path) -> io::Result { - Ok(match mode { - MergeMode::Presence => MatrixBuilder::Bit(PersistentBitMatrixBuilder::new(n, dir)?), - MergeMode::Count => MatrixBuilder::Int(PersistentCompactIntMatrixBuilder::new(n, dir)?), - }) - } - - fn resume(mode: MergeMode, dir: &Path) -> io::Result { - Ok(match mode { - MergeMode::Presence => MatrixBuilder::Bit(PersistentBitMatrixBuilder::resume(dir)?), - MergeMode::Count => MatrixBuilder::Int(PersistentCompactIntMatrixBuilder::resume(dir)?), - }) - } - - /// Add a column with no data written (all-zero/false) — for genome - /// columns absent from this source (e.g. dst genomes in a new layer). - fn add_absent_col(&mut self) -> io::Result<()> { - match self { - MatrixBuilder::Bit(b) => b.add_col()?.close(), - MatrixBuilder::Int(b) => b.add_col()?.close(), - } - } - - fn add_col(&mut self) -> io::Result { - Ok(match self { - MatrixBuilder::Bit(b) => ColBuilder::Bit(b.add_col()?), - MatrixBuilder::Int(b) => ColBuilder::Int(b.add_col()?), - }) - } - - fn close(self) -> io::Result<()> { - match self { - MatrixBuilder::Bit(b) => b.close(), - MatrixBuilder::Int(b) => b.close(), - } - } -} - -#[cfg(test)] -mod matrix_builder_tests { - use tempfile::tempdir; - - use obicompactvec::{PersistentBitMatrix, PersistentCompactIntMatrix}; - - use super::{ColBuilder, MatrixBuilder, MergeMode}; - - /// Mirrors `merge_partition`'s "new layer" setup: absent (dst-genome) - /// columns get no data, then source columns are filled — all through one - /// continuous `MatrixBuilder` session, closed once at the end. - #[test] - fn new_layer_absent_then_source_columns_presence() { - let dir = tempdir().unwrap(); - let data_dir = dir.path().join("presence"); - let mut mb = MatrixBuilder::new(MergeMode::Presence, 3, &data_dir).unwrap(); - - // Two absent (dst-genome) columns. - mb.add_absent_col().unwrap(); - mb.add_absent_col().unwrap(); - - // One source column, filled like pass 2 would. - let mut col = mb.add_col().unwrap(); - match &mut col { - ColBuilder::Bit(b) => { - b.set(0, true); - b.set(1, false); - b.set(2, true); - } - ColBuilder::Int(_) => unreachable!(), - } - col.close().unwrap(); - mb.close().unwrap(); - - let m = PersistentBitMatrix::open(dir.path()).unwrap(); - assert_eq!(m.n_cols(), 3); - assert_eq!(&*m.row(0), &[false, false, true]); - assert_eq!(&*m.row(1), &[false, false, false]); - assert_eq!(&*m.row(2), &[false, false, true]); - } - - #[test] - fn new_layer_absent_then_source_columns_count() { - let dir = tempdir().unwrap(); - let data_dir = dir.path().join("counts"); - let mut mb = MatrixBuilder::new(MergeMode::Count, 2, &data_dir).unwrap(); - - mb.add_absent_col().unwrap(); - - let mut col = mb.add_col().unwrap(); - match &mut col { - ColBuilder::Int(b) => { - b.set(0, 7); - b.set(1, 42); - } - ColBuilder::Bit(_) => unreachable!(), - } - col.close().unwrap(); - mb.close().unwrap(); - - let m = PersistentCompactIntMatrix::open(dir.path()).unwrap(); - assert_eq!(m.n_cols(), 2); - assert_eq!(&*m.row(0), &[0u32, 7]); - assert_eq!(&*m.row(1), &[0u32, 42]); - } - - /// Mirrors `merge_partition`'s "existing dst layer" setup: an - /// already-closed matrix (from a previous merge) gets more columns - /// appended via `resume`, without callers ever seeing `col_path`/ - /// `MatrixMeta` — `n` itself is read back from the matrix directory. - #[test] - fn resume_appends_source_columns_to_existing_layer() { - let dir = tempdir().unwrap(); - let data_dir = dir.path().join("presence"); - - // Previous merge: one dst-genome column already on disk. - let mut mb0 = MatrixBuilder::new(MergeMode::Presence, 3, &data_dir).unwrap(); - mb0.add_absent_col().unwrap(); - mb0.close().unwrap(); - - // This merge: resume and append two more source columns. - let mut mb = MatrixBuilder::resume(MergeMode::Presence, &data_dir).unwrap(); - for vals in [[true, false, true], [false, true, false]] { - let mut col = mb.add_col().unwrap(); - match &mut col { - ColBuilder::Bit(b) => { - for (slot, v) in vals.into_iter().enumerate() { - b.set(slot, v); - } - } - ColBuilder::Int(_) => unreachable!(), - } - col.close().unwrap(); - } - mb.close().unwrap(); - - let m = PersistentBitMatrix::open(dir.path()).unwrap(); - assert_eq!(m.n_cols(), 3); - assert_eq!(&*m.row(0), &[false, true, false]); - assert_eq!(&*m.row(1), &[false, false, true]); - assert_eq!(&*m.row(2), &[false, true, false]); - } -} - -// ── KmerPartition::merge_partition ──────────────────────────────────────────── - -impl KmerIndex { - /// Merge `sources` into destination partition `i`. - /// - /// Each entry in `sources` is `(partition, n_genomes)` where `n_genomes` is - /// the number of genome columns that source contributes. A merged index - /// contributes more than one. The total new columns added to the destination - /// is `sum(n_genomes)`. - /// - /// `n_dst_genomes` is the number of genome columns already in the destination - /// matrices (copied from source_0 before this call). - pub fn merge_partition( - &self, - i: usize, - sources: &[(&KmerIndex, usize)], - mode: MergeMode, - n_dst_genomes: usize, - block_bits: u8, - evidence: &IndexMode, - ) -> OKIResult { - let dst_index_dir = self.index_dir(i); - if !dst_index_dir.exists() { - return Ok(0); - } - - load_meta(&dst_index_dir)?; // ensure meta.json exists before LayeredMap::open - let dst_map = Arc::new(LayeredMap::<()>::open(&dst_index_dir)?); - let n_dst_layers = dst_map.n_layers(); - let n_src_total: usize = sources.iter().map(|(_, n)| *n).sum(); - - // First merge in presence mode: init presence matrices on existing layers - // (all slots true — every kmer in those layers belongs to genome_0). - if n_dst_genomes == 1 && mode == MergeMode::Presence { - for l in 0..n_dst_layers { - TypedLayer::<()>::init_presence_matrix( - &layer_dir(&dst_index_dir, l), - dst_map.layer(l).n(), - )?; - } - } - - // ── Pass 1: pipeline — parallel file read + dst_map filter + graph fill ─ - // - // Source : list of unitigs.bin paths (one per source × layer) - // Flat : open file, emit Vec batches (BeeGFS parallel I/O) - // Transform: filter via dst_map.query() — thread-safe, LayeredMap<()>: Sync - // Sink : push new kmers into GraphDeBruijn (single thread, no locks needed) - - // Collect file paths (propagates load_meta errors before the pipeline starts) - let mut unitig_paths: Vec = Vec::new(); - for (src, _) in sources.iter() { - let src_index_dir = src.index_dir(i); - if !src_index_dir.exists() { - continue; - } - let src_meta = load_meta(&src_index_dir)?; - for l in 0..src_meta.n_layers { - let p = layer_dir(&src_index_dir, l).join("unitigs.bin"); - if p.exists() { - unitig_paths.push(p); - } - } - } - - let n_src_layers = unitig_paths.len(); - debug!("partition {i}: de Bruijn graph build start — {n_src_layers} source layer(s)"); - - const BATCH: usize = 4096; - let n_workers = rayon::current_num_threads().min(16).max(4); - // At most 2 files open simultaneously: keeps n_workers-2 workers free - // for the Transform stage. Each open file monopolises one worker for the - // full duration of its read, so this must stay well below n_workers. - let max_open = 2; - - let dst_filter = Arc::clone(&dst_map); - - let g = build_graph( - unitig_paths.into_iter(), - move |path: PathBuf, emit: &mut dyn FnMut(Vec)| -> OKIResult<()> { - let reader = UnitigFileReader::open_sequential(&path)?; - let mut batch: Vec = Vec::with_capacity(BATCH); - for (kmer, _, _) in reader.iter_indexed_canonical_kmers() { - batch.push(kmer); - if batch.len() == BATCH { - emit(std::mem::replace(&mut batch, Vec::with_capacity(BATCH))); - } - } - if !batch.is_empty() { - emit(batch); - } - Ok(()) - }, - move |kmer| dst_filter.query(kmer).is_none(), - n_workers, - max_open, - )?; - - let any_new = g.len() > 0; - debug!( - "partition {i}: de Bruijn graph done — {} new kmers", - g.len() - ); - - // Build new layer from de Bruijn graph if there are new kmers. - let new_layer_idx = n_dst_layers; - let new_layer_dir = layer_dir(&dst_index_dir, new_layer_idx); - - let n_new = if any_new { - debug!("partition {i}: unitig traversal start — {} nodes", g.len()); - let n_nodes = materialize_layer(g, &new_layer_dir, block_bits, evidence)?; - debug!("partition {i}: MPHF build done"); - n_nodes - } else { - drop(g); - 0 - }; - - let t_open = std::time::Instant::now(); - let new_mphf: Option> = if any_new { - Some(Arc::new(MphfOnly::open(&new_layer_dir)?)) - } else { - None - }; - debug!( - "partition {i}: MPHF open in {:.3}s", - t_open.elapsed().as_secs_f64() - ); - - // ── Prepare matrix directories for the new layer ────────────────────── - // Absent columns (dst genomes) get an all-zero/false column. Source-genome - // columns are created as mutable builders for pass 2. `new_mb` is kept - // open (not `close`d) until pass 2 has filled every source column, so its - // `n_cols` bookkeeping stays in sync with the columns actually created. - let (new_src_builders, new_mb): (Vec, Option) = if any_new { - let data_dir = match mode { - MergeMode::Presence => new_layer_dir.join("presence"), - MergeMode::Count => new_layer_dir.join("counts"), - }; - fs::create_dir_all(&data_dir)?; - let mut mb = MatrixBuilder::new(mode, n_new, &data_dir).map_err(OKIError::Io)?; - for _ in 0..n_dst_genomes { - mb.add_absent_col().map_err(OKIError::Io)?; - } - let cols = (0..n_src_total) - .map(|_| mb.add_col().map_err(OKIError::Io)) - .collect::>>()?; - (cols, Some(mb)) - } else { - (vec![], None) - }; - - let t_builders = std::time::Instant::now(); - // Builders for existing layers: n_src_total per layer, resumed from - // each layer's own matrix directory (already holding n_dst_genomes - // columns from a previous merge). Columns land at - // n_dst_genomes .. n_dst_genomes + n_src_total - 1. - let mut exist_mbs: Vec = Vec::with_capacity(n_dst_layers); - let mut exist_builders: Vec> = Vec::with_capacity(n_dst_layers); - for l in 0..n_dst_layers { - let layer_dir = layer_dir(&dst_index_dir, l); - let data_dir = match mode { - MergeMode::Presence => layer_dir.join("presence"), - MergeMode::Count => layer_dir.join("counts"), - }; - let mut mb = MatrixBuilder::resume(mode, &data_dir).map_err(OKIError::Io)?; - let cols = (0..n_src_total) - .map(|_| mb.add_col().map_err(OKIError::Io)) - .collect::>>()?; - exist_mbs.push(mb); - exist_builders.push(cols); - } - - debug!( - "partition {i}: builders ready in {:.3}s", - t_builders.elapsed().as_secs_f64() - ); - - // ── Pass 2: fill builders (pipeline) ───────────────────────────────── - let t_pass2 = std::time::Instant::now(); - // Collect source items before the pipeline so load_meta errors propagate - // via ? before any worker thread is spawned. - let mut pass2_items: Vec<(usize, usize, PathBuf)> = Vec::new(); - { - let mut col_offset = 0usize; - for (src, src_n) in sources.iter() { - let src_index_dir = src.index_dir(i); - if !src_index_dir.exists() { - col_offset += src_n; - continue; - } - let src_meta = load_meta(&src_index_dir)?; - for l in 0..src_meta.n_layers { - let src_layer_dir = layer_dir(&src_index_dir, l); - if src_layer_dir.join("unitigs.bin").exists() { - pass2_items.push((col_offset, *src_n, src_layer_dir)); - } - } - col_offset += src_n; - } - } - - enum Pass2Data { - SrcLayer((usize, usize, PathBuf, ThrottleGuard)), - RawBatch((usize, usize, Arc, Vec)), - WriteBatch(Vec<(Option, usize, usize, u32)>), - } - - let exist_locked: Vec>>> = exist_builders - .into_iter() - .map(|layer| layer.into_iter().map(|b| Arc::new(Mutex::new(b))).collect()) - .collect(); - let new_locked: Vec>> = new_src_builders - .into_iter() - .map(|b| Arc::new(Mutex::new(b))) - .collect(); - let exist_sink: Vec>>> = exist_locked - .iter() - .map(|layer| layer.iter().map(Arc::clone).collect()) - .collect(); - let new_sink: Vec>> = new_locked.iter().map(Arc::clone).collect(); - let dst_map_t2 = Arc::clone(&dst_map); - let new_mphf_t2 = new_mphf.clone(); - let pass2_err: Arc>> = Arc::new(Mutex::new(None)); - let err_cap2 = Arc::clone(&pass2_err); - - let capacity = 2; - let throttled_pass2 = throttle(pass2_items.into_iter(), max_open); - - let pipeline2 = Pipeline::new( - make_source!( - Pass2Data, - throttled_pass2.map(|t| { - let (col_offset, src_n, src_layer_dir) = t.item; - (col_offset, src_n, src_layer_dir, t.guard) - }), - SrcLayer - ), - vec![ - Stage::Flat(Arc::new( - move |data: Pass2Data, - push: &PipelineSender>, - delta: &PipelineSender| { - if let Pass2Data::SrcLayer((col_offset, src_n, src_layer_dir, _guard)) = - data - { - // _guard dropped at end of block, releasing the slot. - let reader = match UnitigFileReader::open_sequential( - &src_layer_dir.join("unitigs.bin"), - ) { - Ok(r) => r, - Err(e) => { - *err_cap2.lock().unwrap() = Some(e.to_string()); - delta.send(-1).ok(); - return; - } - }; - let src_data = match SrcLayerData::open(&src_layer_dir, mode) { - Ok(d) => Arc::new(d), - Err(e) => { - *err_cap2.lock().unwrap() = Some(e.to_string()); - delta.send(-1).ok(); - return; - } - }; - const BATCH: usize = 4096; - let mut batch: Vec = Vec::with_capacity(BATCH); - let mut count: isize = 0; - for (kmer, _, _) in reader.iter_indexed_canonical_kmers() { - batch.push(kmer); - if batch.len() == BATCH { - let b = - std::mem::replace(&mut batch, Vec::with_capacity(BATCH)); - push.send(Ok(Pass2Data::RawBatch(( - col_offset, - src_n, - Arc::clone(&src_data), - b, - )))) - .ok(); - count += 1; - } - } - if !batch.is_empty() { - push.send(Ok(Pass2Data::RawBatch(( - col_offset, src_n, src_data, batch, - )))) - .ok(); - count += 1; - } - delta.send(count - 1).ok(); - } - }, - ) as SharedFlatFn), - make_transform!( - Pass2Data, - { - move |(col_offset, src_n, src_data, kmers): ( - usize, - usize, - Arc, - Vec, - )| - -> Vec<(Option, usize, usize, u32)> { - let mut ops: Vec<(Option, usize, usize, u32)> = Vec::new(); - for kmer in kmers { - let values = src_data.lookup(kmer, src_n); - if let Some((dst_layer, hit)) = dst_map_t2.query(kmer) { - for (g, val) in values.into_iter().enumerate() { - ops.push((Some(dst_layer), col_offset + g, hit.slot, val)); - } - } else if let Some(ref mphf) = new_mphf_t2 { - let slot = mphf.index(kmer); - for (g, val) in values.into_iter().enumerate() { - ops.push((None, col_offset + g, slot, val)); - } - } - } - ops - } - }, - RawBatch, - WriteBatch - ), - ], - make_sink!( - Pass2Data, - { - move |ops: Vec<(Option, usize, usize, u32)>| { - for (layer_opt, col, slot, val) in ops { - match layer_opt { - Some(l) => exist_sink[l][col].lock().unwrap().set_val(slot, val), - None => new_sink[col].lock().unwrap().set_val(slot, val), - } - } - } - }, - WriteBatch - ), - ); - - WorkerPool::new(pipeline2, n_workers, capacity).run(); - debug!( - "partition {i}: pass2 pipeline done in {:.3}s", - t_pass2.elapsed().as_secs_f64() - ); - - if let Some(msg) = Arc::try_unwrap(pass2_err) - .unwrap_or_else(|_| panic!("pass2: pass2_err not uniquely owned")) - .into_inner() - .unwrap_or_else(|e| e.into_inner()) - { - return Err(OKIError::InvalidData { - context: "merge pass2", - detail: msg, - }); - } - - let t_close = std::time::Instant::now(); - // ── Close builders and update metadata ──────────────────────────────── - for (mb, builders) in exist_mbs.into_iter().zip(exist_locked.into_iter()) { - for b in builders { - Arc::try_unwrap(b) - .unwrap_or_else(|_| panic!("pass2: exist_builder not uniquely owned")) - .into_inner() - .unwrap_or_else(|e| e.into_inner()) - .close()?; - } - mb.close().map_err(OKIError::Io)?; - } - - for b in new_locked { - Arc::try_unwrap(b) - .unwrap_or_else(|_| panic!("pass2: new_builder not uniquely owned")) - .into_inner() - .unwrap_or_else(|e| e.into_inner()) - .close()?; - } - if let Some(mb) = new_mb { - mb.close().map_err(OKIError::Io)?; - - let mut part_meta = self.partition_meta(i)?; - part_meta.n_layers = new_layer_idx + 1; - part_meta - .save(&dst_index_dir)?; - } - - debug!( - "partition {i}: builders closed in {:.3}s", - t_close.elapsed().as_secs_f64() - ); - - Ok(n_new) - } -} diff --git a/src/obikmerge/src/merge_layer/src_layer.rs b/src/obikmerge/src/merge_layer/src_layer.rs deleted file mode 100644 index 5078f735..00000000 --- a/src/obikmerge/src/merge_layer/src_layer.rs +++ /dev/null @@ -1,94 +0,0 @@ -use std::path::Path; - -use obicompactvec::{MatrixGroupOps, PersistentBitMatrix, PersistentCompactIntMatrix}; -use obikseq::CanonicalKmer; -use obikindex::layer::MphfOnly; -use obikindex::{OKIError, OKIResult}; - - -use super::MergeMode; - -// ── SrcLayerData — opened source matrix for pass-2 lookup ───────────────────── - -pub enum SrcLayerData { - Presence(MphfOnly, PersistentBitMatrix), - Count(MphfOnly, PersistentCompactIntMatrix), -} - -impl SrcLayerData { - pub fn open(layer_dir: &Path, merge_mode: MergeMode) -> OKIResult { - let counts_dir = layer_dir.join("counts"); - match merge_mode { - MergeMode::Presence => { - if counts_dir.exists() && !layer_dir.join("presence").exists() { - let mphf = MphfOnly::open(layer_dir)?; - let mat = PersistentCompactIntMatrix::open(layer_dir).map_err(OKIError::Io)?; - Ok(SrcLayerData::Count(mphf, mat)) - } else { - // presence dir exists, or neither exists → Implicit handled by open() - let mphf = MphfOnly::open(layer_dir)?; - let mat = PersistentBitMatrix::open(layer_dir).map_err(OKIError::Io)?; - Ok(SrcLayerData::Presence(mphf, mat)) - } - } - MergeMode::Count => { - let mphf = MphfOnly::open(layer_dir)?; - if counts_dir.exists() { - let mat = PersistentCompactIntMatrix::open(layer_dir).map_err(OKIError::Io)?; - Ok(SrcLayerData::Count(mphf, mat)) - } else { - // No counts → treat as implicit presence (all 1s) - let mat = PersistentBitMatrix::open(layer_dir).map_err(OKIError::Io)?; - Ok(SrcLayerData::Presence(mphf, mat)) - } - } - } - } - - /// Return one value per source genome for `kmer`. - /// The caller guarantees `kmer` is in the source MPHF domain. - #[inline] - pub(crate) fn lookup(&self, kmer: CanonicalKmer, n_genomes: usize) -> Vec { - let mut buf = vec![0u32; n_genomes]; - match self { - SrcLayerData::Presence(mphf, mat) => mat.fill_row(mphf.index(kmer), &mut buf), - SrcLayerData::Count(mphf, mat) => mat.fill_row(mphf.index(kmer), &mut buf), - } - buf - } - - pub fn n_slots(&self) -> usize { - match self { - SrcLayerData::Presence(_, mat) => mat.n(), - SrcLayerData::Count(_, mat) => mat.n(), - } - } - - /// MPHF lookup: returns the slot index for `kmer` (kmer must be in the domain). - #[inline] - pub fn slot(&self, kmer: CanonicalKmer) -> usize { - match self { - SrcLayerData::Presence(mphf, _) => mphf.index(kmer), - SrcLayerData::Count(mphf, _) => mphf.index(kmer), - } - } - - /// Row lookup by slot index, bypassing the MPHF. - #[inline] - pub fn fill_row_by_slot(&self, slot: usize, n_genomes: usize) -> Vec { - let mut buf = vec![0u32; n_genomes]; - match self { - SrcLayerData::Presence(_, mat) => mat.fill_row(slot, &mut buf), - SrcLayerData::Count(_, mat) => mat.fill_row(slot, &mut buf), - } - buf - } - - /// Call `f` with a reference to the underlying matrix as `&dyn MatrixGroupOps`. - pub fn with_matrix(&self, f: impl FnOnce(&dyn MatrixGroupOps) -> R) -> R { - match self { - SrcLayerData::Presence(_, mat) => f(mat), - SrcLayerData::Count(_, mat) => f(mat), - } - } -}