From 8b870784785e677f47a2c51dd8f802a10129ac0a Mon Sep 17 00:00:00 2001 From: Eric Coissac Date: Wed, 14 Oct 2026 19:09:34 +0200 Subject: [PATCH] Implement MPHF migration tool and sparse matrix permutation logic Refactors sparse matrix handling to implement row permutation logic and introduces a standalone tool for migrating indexes from MPHF 1.x to 2.x formats. --- .gitea/workflows/release.yml | 25 +- .gitignore | 1 + Makefile | 12 + src/Cargo.lock | 2 - src/obicompactvec/src/bitmatrix/sparse.rs | 25 + src/obicompactvec/src/sparse_intmatrix.rs | 23 + src/obicompactvec/src/tests/sparse.rs | 28 + .../src/tests/sparse_intmatrix.rs | 29 + src/obikindex/src/index/kmer_index.rs | 8 + src/obikindex/src/layer/mod.rs | 4 +- src/obikindex/src/layer/mphf_layer.rs | 12 +- src/obikindexer/Cargo.toml | 2 - .../src/algorithms/counter/count.rs | 7 +- .../src/extensions/private_builder.rs | 6 +- tools/migrate-mphf/Cargo.lock | 3216 +++++++++++++++++ tools/migrate-mphf/Cargo.toml | 36 + tools/migrate-mphf/src/commit.rs | 98 + tools/migrate-mphf/src/data.rs | 100 + tools/migrate-mphf/src/layer.rs | 75 + tools/migrate-mphf/src/main.rs | 121 + tools/migrate-mphf/src/old.rs | 17 + tools/migrate-mphf/src/plan.rs | 53 + tools/migrate-mphf/src/util.rs | 11 + tools/migrate-mphf/src/verify.rs | 90 + 24 files changed, 3982 insertions(+), 19 deletions(-) create mode 100644 tools/migrate-mphf/Cargo.lock create mode 100644 tools/migrate-mphf/Cargo.toml create mode 100644 tools/migrate-mphf/src/commit.rs create mode 100644 tools/migrate-mphf/src/data.rs create mode 100644 tools/migrate-mphf/src/layer.rs create mode 100644 tools/migrate-mphf/src/main.rs create mode 100644 tools/migrate-mphf/src/old.rs create mode 100644 tools/migrate-mphf/src/plan.rs create mode 100644 tools/migrate-mphf/src/util.rs create mode 100644 tools/migrate-mphf/src/verify.rs diff --git a/.gitea/workflows/release.yml b/.gitea/workflows/release.yml index 9951ae90..bdbdf696 100644 --- a/.gitea/workflows/release.yml +++ b/.gitea/workflows/release.yml @@ -62,7 +62,8 @@ jobs: ~/.cargo/registry ~/.cargo/git src/target - key: linux-musl-cargo-${{ hashFiles('src/Cargo.lock') }} + tools/migrate-mphf/target + key: linux-musl-cargo-${{ hashFiles('src/Cargo.lock', 'tools/migrate-mphf/Cargo.lock') }} restore-keys: linux-musl-cargo- - name: Build static binary @@ -83,6 +84,28 @@ jobs: -H "Authorization: token $GITEA_TOKEN" \ -F "attachment=@/tmp/dist/obikmer-linux-x86_64" + # One-shot converter for indexes built with ptr_hash 1.x. A standalone + # crate (own Cargo.lock/target, outside src/'s workspace), built after + # obikmer's own asset is already uploaded: it never blocks that one. + - name: Build migrate-mphf (static) + working-directory: tools/migrate-mphf + env: + PKG_CONFIG_ALLOW_CROSS: "1" + run: cargo zigbuild --release --target x86_64-unknown-linux-musl + + - name: Upload migrate-mphf artifact + working-directory: tools/migrate-mphf + env: + GITEA_TOKEN: ${{ secrets.GITEATOKEN }} + RELEASE_ID: ${{ needs.create-release.outputs.release_id }} + run: | + cp target/x86_64-unknown-linux-musl/release/migrate-mphf /tmp/dist/migrate-mphf-linux-x86_64 + strip /tmp/dist/migrate-mphf-linux-x86_64 + curl -s -X POST \ + "${{ github.server_url }}/api/v1/repos/${{ github.repository }}/releases/$RELEASE_ID/assets" \ + -H "Authorization: token $GITEA_TOKEN" \ + -F "attachment=@/tmp/dist/migrate-mphf-linux-x86_64" + build-macos-arm64: needs: create-release runs-on: ubuntu-latest diff --git a/.gitignore b/.gitignore index f0bf8a7c..2230b394 100644 --- a/.gitignore +++ b/.gitignore @@ -9,6 +9,7 @@ CLAUDE.md memory/ sandbox/ src/target +tools/migrate-mphf/target data-stress *.fasta *.fasta.gz diff --git a/Makefile b/Makefile index 2057bbea..e6fa40ad 100644 --- a/Makefile +++ b/Makefile @@ -42,6 +42,18 @@ obikmer: debug: cargo build --manifest-path $(CARGO_DIR)/Cargo.toml --bin obikmer +# One-shot converter of indexes built with ptr_hash 1.x (see tools/migrate-mphf). +# Standalone crate, outside the src/ workspace, with its own Cargo.lock/target. +MIGRATE_MPHF_DIR := tools/migrate-mphf + +.PHONY: migrate-mphf +migrate-mphf: + cargo build --release --manifest-path $(MIGRATE_MPHF_DIR)/Cargo.toml + +.PHONY: clean-migrate-mphf +clean-migrate-mphf: + rm -rf $(MIGRATE_MPHF_DIR)/target + .PHONY: profile-build profile-build: cargo build --release --manifest-path $(CARGO_DIR)/Cargo.toml \ diff --git a/src/Cargo.lock b/src/Cargo.lock index 545fb99c..f26cec49 100644 --- a/src/Cargo.lock +++ b/src/Cargo.lock @@ -1528,7 +1528,6 @@ dependencies = [ name = "obikindexer" version = "0.1.0" dependencies = [ - "cacheline-ef", "epserde", "memmap2", "niffler", @@ -1543,7 +1542,6 @@ dependencies = [ "obiskbuilder", "obiskio", "obisys", - "ptr_hash", "rayon", "serde", "serde_json", diff --git a/src/obicompactvec/src/bitmatrix/sparse.rs b/src/obicompactvec/src/bitmatrix/sparse.rs index c13059a6..2ce59ca7 100644 --- a/src/obicompactvec/src/bitmatrix/sparse.rs +++ b/src/obicompactvec/src/bitmatrix/sparse.rs @@ -514,6 +514,31 @@ impl PersistentSparseBitMatrixBuilder { } Ok(builder) } + + /// Builds the row-permuted copy of `src` into `dir`: row `s` of the + /// result is row `new_to_old[s]` of `src`. `new_to_old` must have + /// `src.n()` entries and be a permutation of `0..src.n()` — the caller + /// proves that, this only reads `src` at those slots. + /// + /// Needed whenever the slot numbering of a layer changes (its MPHF is + /// rebuilt) while the data attached to each k-mer must follow it. + /// Rows are read at arbitrary slots of `src`, so convert a dense source + /// to sparse first (`build_from_dense`) rather than permuting it + /// cell by cell. + pub fn build_permuted( + src: &PersistentSparseBitMatrix, + new_to_old: &[u32], + dir: &Path, + ) -> io::Result { + let mut builder = Self::new(new_to_old.len(), src.n_cols(), dir)?; + let mut genomes: Vec = Vec::new(); + for &old in new_to_old { + genomes.clear(); + src.for_each_genome_in_row(old as usize, |g| genomes.push(g as u32)); + builder.push_row(&genomes); + } + Ok(builder) + } } // ── Trait impls ─────────────────────────────────────────────────────────────── diff --git a/src/obicompactvec/src/sparse_intmatrix.rs b/src/obicompactvec/src/sparse_intmatrix.rs index 23675f4a..e2534cc7 100644 --- a/src/obicompactvec/src/sparse_intmatrix.rs +++ b/src/obicompactvec/src/sparse_intmatrix.rs @@ -548,6 +548,29 @@ impl PersistentSparseCompactIntMatrixBuilder { Ok(builder) } + /// Row-permuted copy of `src`: row `s` of the result is row + /// `new_to_old[s]` of `src`. Same contract as + /// [`PersistentSparseBitMatrixBuilder::build_permuted`]. + pub fn build_permuted( + src: &PersistentSparseCompactIntMatrix, + new_to_old: &[u32], + dir: &Path, + ) -> io::Result { + let mut builder = Self::new(new_to_old.len(), src.n_cols(), dir)?; + let mut cols: Vec = Vec::new(); + let mut vals: Vec = Vec::new(); + for &old in new_to_old { + cols.clear(); + vals.clear(); + src.for_each_cell_in_row(old as usize, |c, v| { + cols.push(c as u32); + vals.push(v); + }); + builder.push_row(&cols, &vals); + } + Ok(builder) + } + pub fn close(self) -> io::Result<()> { let Self { support, diff --git a/src/obicompactvec/src/tests/sparse.rs b/src/obicompactvec/src/tests/sparse.rs index 45aa32ec..b48ba8c2 100644 --- a/src/obicompactvec/src/tests/sparse.rs +++ b/src/obicompactvec/src/tests/sparse.rs @@ -415,3 +415,31 @@ fn partial_jaccard_and_hamming_match_dense_including_diagonal() { drop(dir_dense); drop(dir_sparse); } + +#[test] +fn build_permuted_follows_the_permutation() { + // Mix of singleton and multi rows, including a repeated multi set, so the + // dictionary dedup is exercised on the permuted order too. + let rows: Vec<&[bool]> = vec![ + &[true, false, false, false], + &[false, false, true, false], + &[true, true, false, false], + &[false, false, true, true], + &[true, true, false, false], + ]; + let (_dir, src) = make_sparse(&rows, 4); + let new_to_old: Vec = vec![3, 0, 4, 1, 2]; + + let out = tempdir().unwrap(); + let permuted = + PersistentSparseBitMatrixBuilder::build_permuted(&src, &new_to_old, &out.path().join("p")) + .unwrap() + .finish() + .unwrap(); + + assert_eq!(permuted.n(), src.n()); + assert_eq!(permuted.n_cols(), src.n_cols()); + for (new, &old) in new_to_old.iter().enumerate() { + assert_eq!(row_as_bool(&permuted, new), row_as_bool(&src, old as usize), "new row {new}"); + } +} diff --git a/src/obicompactvec/src/tests/sparse_intmatrix.rs b/src/obicompactvec/src/tests/sparse_intmatrix.rs index 3c41683e..58a656c2 100644 --- a/src/obicompactvec/src/tests/sparse_intmatrix.rs +++ b/src/obicompactvec/src/tests/sparse_intmatrix.rs @@ -304,3 +304,32 @@ fn pack_sparse_compact_int_matrix_from_already_packed_matrix() { assert_eq!(&*sparse.row(slot), &**expected, "slot {slot}"); } } + +#[test] +fn build_permuted_follows_the_permutation() { + // Rows sharing a support with different values, plus singletons. + let rows: Vec<&[u32]> = vec![ + &[7, 0, 0, 0], + &[0, 0, 3, 0], + &[2, 5, 0, 0], + &[9, 1, 0, 0], + &[0, 0, 4, 6], + ]; + let (_dir, src) = make_sparse(&rows, 4); + let new_to_old: Vec = vec![4, 2, 0, 3, 1]; + + let out = tempdir().unwrap(); + let permuted = PersistentSparseCompactIntMatrixBuilder::build_permuted( + &src, + &new_to_old, + &out.path().join("p"), + ) + .unwrap() + .finish() + .unwrap(); + + assert_eq!(permuted.n(), src.n()); + for (new, &old) in new_to_old.iter().enumerate() { + assert_eq!(permuted.row(new), src.row(old as usize), "new row {new}"); + } +} diff --git a/src/obikindex/src/index/kmer_index.rs b/src/obikindex/src/index/kmer_index.rs index 06c0d6f2..3cf4fcb5 100644 --- a/src/obikindex/src/index/kmer_index.rs +++ b/src/obikindex/src/index/kmer_index.rs @@ -210,6 +210,14 @@ impl KmerIndex { crate::partition::index_dir(&self.root_path, i) } + /// Path of layer `j` of partition `i` — pure path computation, nothing + /// is opened (unlike [`layer`](Self::layer)/`layer_dir`, which open the + /// layer's MPHF). For maintenance tools that must reach a layer's files + /// without going through a format they can't read yet. + pub fn layer_path(&self, i: usize, j: usize) -> PathBuf { + crate::layer::utils::layer_dir(&self.index_dir(i), j) + } + /// Number of layers in partition `i` — a disk scan, not a metadata read /// (see [`KmerPartition::n_layers`](crate::partition::KmerPartition::n_layers)). pub fn n_layers(&self, i: usize) -> OKIResult { diff --git a/src/obikindex/src/layer/mod.rs b/src/obikindex/src/layer/mod.rs index c06950d1..fff87161 100644 --- a/src/obikindex/src/layer/mod.rs +++ b/src/obikindex/src/layer/mod.rs @@ -9,5 +9,7 @@ pub(crate) mod utils; pub use crate::index::error::{OKIError, OKIResult}; pub use content_layer::KmerLayer; pub use meta::IndexMode; -pub use mphf_layer::{EvidenceKind, KmerBatchIter, KmerIter, MphfLayer, MphfOnly, UnitigIter}; +pub use mphf_layer::{ + EvidenceKind, KmerBatchIter, KmerIter, Mphf, MphfLayer, MphfOnly, UnitigIter, mphf_params, +}; pub use typed_layer::{HasLayerContent, HasStorageKind, Hit, LayerContent, LayerData, TypedLayer}; diff --git a/src/obikindex/src/layer/mphf_layer.rs b/src/obikindex/src/layer/mphf_layer.rs index 5932503c..815b9a6d 100644 --- a/src/obikindex/src/layer/mphf_layer.rs +++ b/src/obikindex/src/layer/mphf_layer.rs @@ -23,7 +23,13 @@ pub(crate) const FINGERPRINT_FILE: &str = "fingerprint.bin"; /// The layer MPHF: `Xxh3Int` hasher, `CubicEps` buckets, multi-part (`SINGLE_PART = false`), /// minimal (`REMAP = true`). Built owned (construction + store); queried through /// `MemCase::uncase()`, the ε-copy view into the memory-mapped file. -pub(crate) type Mphf = PtrHash>, Xxh3Int, Vec, false, true>; +pub type Mphf = PtrHash>, Xxh3Int, Vec, false, true>; + +/// Construction parameters of [`Mphf`] — the one place they are chosen +/// (`lambda = 3.5`, `alpha = 0.99`, `CubicEps`, ~2.4 bits/key). +pub fn mphf_params() -> PtrHashParams { + PtrHashParams::::default_balanced() +} // ── LayerEvidence ───────────────────────────────────────────────────────────── @@ -550,7 +556,7 @@ impl MphfLayer { // ── Empty layer ─────────────────────────────────────────────────────── if n == 0 { - let mphf: Mphf = Mphf::try_new(&[] as &[u64], PtrHashParams::::default_balanced()) + let mphf: Mphf = Mphf::try_new(&[] as &[u64], mphf_params()) .ok_or_else(|| OKIError::InvalidData { context: "mphf", detail: "construction failed".into() })?; unsafe { mphf.store(&dir.join(MPHF_FILE)) } .map_err(|e| OKIError::InvalidData { context: "layer", detail: e.to_string() })?; @@ -574,7 +580,7 @@ impl MphfLayer { let mphf: Mphf = Mphf::new_from_par_iter( n, keys.map(|k| k.raw()).par_bridge(), - PtrHashParams::::default_balanced(), + mphf_params(), ); unsafe { mphf.store(&dir.join(MPHF_FILE)) } .map_err(|e| OKIError::InvalidData { context: "layer", detail: e.to_string() })?; diff --git a/src/obikindexer/Cargo.toml b/src/obikindexer/Cargo.toml index af4b88a7..03d00f19 100644 --- a/src/obikindexer/Cargo.toml +++ b/src/obikindexer/Cargo.toml @@ -14,9 +14,7 @@ obicompactvec = { path = "../obicompactvec" } obipipeline = { path = "../obipipeline" } obiread = { path = "../obiread" } obiskbuilder = { path = "../obiskbuilder" } -cacheline-ef = "2.0" epserde = "0.13" -ptr_hash = { version = "2.1", features = ["epserde"] } niffler = "3.0.0" memmap2 = "0.9.10" rayon = "1" diff --git a/src/obikindexer/src/algorithms/counter/count.rs b/src/obikindexer/src/algorithms/counter/count.rs index a9332403..2cc95b03 100644 --- a/src/obikindexer/src/algorithms/counter/count.rs +++ b/src/obikindexer/src/algorithms/counter/count.rs @@ -3,18 +3,15 @@ use std::fs; use std::io; use std::path::Path; -use cacheline_ef::{CachelineEf, CachelineEfVec}; use epserde::ser::Serialize as EpSerialize; use memmap2::Mmap; use obicompactvec::PersistentCompactIntVecBuilder; +use obikindex::layer::{Mphf, mphf_params}; use obiskio::{SKFileReader, SKResult}; -use ptr_hash::{PtrHash, PtrHashParams, bucket_fn::CubicEps, hash::Xxh3Int}; use tracing::debug; use super::kmer_sort::sort_unique_kmers; -pub(super) type Mphf = PtrHash>, Xxh3Int, Vec, false, true>; - fn build_mphf(unique_path: &Path, f0: usize) -> io::Result { let file = fs::File::open(unique_path)?; let mmap = unsafe { Mmap::map(&file)? }; @@ -24,7 +21,7 @@ fn build_mphf(unique_path: &Path, f0: usize) -> io::Result { // Sequential constructor: the outer par_iter over partitions already saturates // the Rayon pool. new_from_par_iter would get no additional threads and adds // coordination overhead. try_new accesses the same mmap'd pages at zero extra cost. - Mphf::try_new(kmers, PtrHashParams::::default_balanced()) + Mphf::try_new(kmers, mphf_params()) .ok_or_else(|| io::Error::other("ptr_hash construction failed")) } diff --git a/src/obikindexer/src/extensions/private_builder.rs b/src/obikindexer/src/extensions/private_builder.rs index c4c224a0..0d655cbc 100644 --- a/src/obikindexer/src/extensions/private_builder.rs +++ b/src/obikindexer/src/extensions/private_builder.rs @@ -25,17 +25,13 @@ use std::io; use std::path::Path; use crate::graph_pipeline::{materialize_layer, write_graph_as_unitigs}; -use cacheline_ef::{CachelineEf, CachelineEfVec}; use epserde::prelude::*; use obicompactvec::{PersistentIntMatrix, PersistentCompactIntVec}; use obidebruinj::GraphDeBruijn; use obikindex::layer::IndexMode; -use obikindex::layer::{KmerLayer, TypedLayer}; +use obikindex::layer::{KmerLayer, Mphf, TypedLayer}; use obikindex::{KmerIndex, OKIError, OKIResult}; use obiskio::{SKError, SKFileMeta, SKFileReader}; -use ptr_hash::{PtrHash, bucket_fn::CubicEps, hash::Xxh3Int}; - -type Mphf = PtrHash>, Xxh3Int, Vec, false, true>; pub(crate) trait PrivateBuilder { /// Mark scatter as complete (`IndexState::Scattered`). diff --git a/tools/migrate-mphf/Cargo.lock b/tools/migrate-mphf/Cargo.lock new file mode 100644 index 00000000..7d68eca9 --- /dev/null +++ b/tools/migrate-mphf/Cargo.lock @@ -0,0 +1,3216 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "adler2" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa" + +[[package]] +name = "ahash" +version = "0.8.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5a15f179cd60c4584b8a8c596927aadc462e27f2ca70c04e0071964a73ba7a75" +dependencies = [ + "cfg-if", + "getrandom 0.3.4", + "once_cell", + "version_check", + "zerocopy", +] + +[[package]] +name = "aho-corasick" +version = "1.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c982642fa9e8606056828ee9a8505737230110bb1099153c79efe865c59d12ba" +dependencies = [ + "memchr", +] + +[[package]] +name = "aliasable" +version = "0.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "250f629c0161ad8107cf89319e990051fae62832fd343083bea452d93e2205fd" + +[[package]] +name = "allocator-api2" +version = "0.2.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923" + +[[package]] +name = "anes" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4b46cbb362ab8752921c97e041f5e366ee6297bd428a31275b9fcf1e380f7299" + +[[package]] +name = "anstream" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "824a212faf96e9acacdbd09febd34438f8f711fb84e09a8916013cd7815ca28d" +dependencies = [ + "anstyle", + "anstyle-parse", + "anstyle-query", + "anstyle-wincon", + "colorchoice", + "is_terminal_polyfill", + "utf8parse", +] + +[[package]] +name = "anstyle" +version = "1.0.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "940b3a0ca603d1eade50a4846a2afffd5ef57a9feac2c0e2ec2e14f9ead76000" + +[[package]] +name = "anstyle-parse" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "52ce7f38b242319f7cabaa6813055467063ecdc9d355bbb4ce0c68908cd8130e" +dependencies = [ + "utf8parse", +] + +[[package]] +name = "anstyle-query" +version = "1.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "40c48f72fd53cd289104fc64099abca73db4166ad86ea0b4341abe65af83dadc" +dependencies = [ + "windows-sys 0.61.2", +] + +[[package]] +name = "anstyle-wincon" +version = "3.0.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d" +dependencies = [ + "anstyle", + "once_cell_polyfill", + "windows-sys 0.61.2", +] + +[[package]] +name = "anyhow" +version = "1.0.104" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "330a5ed07fa54e4702c9d6c4174f74427fc0ef6e214bbd677ae50a5099946470" + +[[package]] +name = "arbitrary-chunks" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2ad8689a486416c401ea15715a4694de30054248ec627edbf31f49cb64ee4086" + +[[package]] +name = "arrayvec" +version = "0.7.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d3fb67a6e08acf24fdeccbac2cb6ac4305825bd1f117462e0e6f2f193345ad56" + +[[package]] +name = "autocfg" +version = "1.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53" + +[[package]] +name = "autotools" +version = "0.2.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ef941527c41b0fc0dd48511a8154cd5fc7e29200a0ff8b7203c5d777dbc795cf" +dependencies = [ + "cc", +] + +[[package]] +name = "base64" +version = "0.23.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac07cdecf99051d9a5238b80f35af32cdeba5b336e55d957b318b50137e18da5" + +[[package]] +name = "bgzip" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b64fd8980fb64af5951bc05de7772b598150a6f7eac42ec17f73e8489915f99b" +dependencies = [ + "flate2", + "log", + "rayon", + "thiserror 1.0.69", +] + +[[package]] +name = "bitflags" +version = "1.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" + +[[package]] +name = "bitflags" +version = "2.13.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3ded4057c258ba199e2d26386d3af3780957ecaee6c4ef4041c6b4b8b97c0b06" + +[[package]] +name = "bitvec" +version = "1.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ddcec3d12c579d40898fe0a9a358a803c23e9c52ca3c425707f81c9436211837" +dependencies = [ + "funty", + "radium", + "tap", + "wyz", +] + +[[package]] +name = "block-buffer" +version = "0.10.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71" +dependencies = [ + "generic-array", +] + +[[package]] +name = "block-pseudorand" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2097358495d244a0643746f4d13eedba4608137008cf9dec54e53a3b700115a6" +dependencies = [ + "chiapos-chacha8", + "nanorand", +] + +[[package]] +name = "bumpalo" +version = "3.20.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72f5acc6cb2ba439de613abc23857ec3d78374d8ed5ac84e9d11336e87da8649" + +[[package]] +name = "byteorder" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b" + +[[package]] +name = "bytes" +version = "1.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fc652a48c352aef3ea3aed32080501cf3ef6ed5da78602a020c991775b0aff04" + +[[package]] +name = "bzip2" +version = "0.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f3a53fac24f34a81bc9954b5d6cfce0c21e18ec6959f44f56e8e90e4bb7c346c" +dependencies = [ + "libbz2-rs-sys", +] + +[[package]] +name = "cacheline-ef" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "af737c6c59cb018ecbe6472cbdf86d39c59d78252febfe311953a991b6e4ed85" +dependencies = [ + "common_traits 0.11.4", + "epserde 0.8.0", + "mem_dbg 0.3.4", +] + +[[package]] +name = "cacheline-ef" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6e701af8ea9f58c4ba18793a5d5dffd791cda99bf766976c59c583939d180fd5" +dependencies = [ + "common_traits 0.13.0", + "epserde 0.13.2", + "mem_dbg 0.4.4", +] + +[[package]] +name = "cast" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5" + +[[package]] +name = "cc" +version = "1.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6651c9ed80effdc7db0ff72512157f901af5e3549e341e24b1dd4887d836d838" +dependencies = [ + "find-msvc-tools", + "jobserver", + "libc", + "shlex", +] + +[[package]] +name = "cfg-if" +version = "1.0.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4e7648175b45a9a48536d676f68d918270699102aa8dab5496df06904c914600" + +[[package]] +name = "cfg_aliases" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f079e83a288787bcd14a6aea84cee5c87a67c5a3e660c30f557a3d24761b3527" + +[[package]] +name = "chacha20" +version = "0.10.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "65c35e4b699c7e15ccbe7ee35c005e4fc0a278d22238a2857e6ce2dadeda1b06" +dependencies = [ + "cfg-if", + "cpufeatures 0.3.1", + "rand_core 0.10.1", +] + +[[package]] +name = "chiapos-chacha8" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "33f8be573a85f6c2bc1b8e43834c07e32f95e489b914bf856c0549c3c269cd0a" +dependencies = [ + "rayon", +] + +[[package]] +name = "ciborium" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "42e69ffd6f0917f5c029256a24d0161db17cea3997d185db0d35926308770f0e" +dependencies = [ + "ciborium-io", + "ciborium-ll", + "serde", +] + +[[package]] +name = "ciborium-io" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "05afea1e0a06c9be33d539b876f1ce3692f4afea2cb41f740e7743225ed1c757" + +[[package]] +name = "ciborium-ll" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "57663b653d948a338bfb3eeba9bb2fd5fcfaecb9e199e87e1eda4d9e8b240fd9" +dependencies = [ + "ciborium-io", + "half", +] + +[[package]] +name = "clap" +version = "4.6.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aa8876b300ab35ba921adea3dfd70157a46249b33f95c9084ae5709785478946" +dependencies = [ + "clap_builder", + "clap_derive", +] + +[[package]] +name = "clap_builder" +version = "4.6.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec0797fb7aeb1406c84efac526901f7ec3ead2124f946b494e72879d4b54704d" +dependencies = [ + "anstream", + "anstyle", + "clap_lex", + "strsim", +] + +[[package]] +name = "clap_derive" +version = "4.6.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f9c751b79415d4e559e3d1fcf128e09e720eb673a06d26cf6f392d37d75b66e0" +dependencies = [ + "heck", + "proc-macro2", + "quote", + "syn 3.0.9", +] + +[[package]] +name = "clap_lex" +version = "1.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1c133bc6a41be0d194c306b5506d15e6feeea7b1d6604bd3f8310dfb2ca96486" + +[[package]] +name = "cmake" +version = "0.1.58" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c0f78a02292a74a88ac736019ab962ece0bc380e3f977bf72e376c5d78ff0678" +dependencies = [ + "cc", +] + +[[package]] +name = "colorchoice" +version = "1.0.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1d07550c9036bf2ae0c684c4297d503f838287c83c53686d05370d0e139ae570" + +[[package]] +name = "colored" +version = "3.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "faf9468729b8cbcea668e36183cb69d317348c2e08e994829fb56ebfdfbaac34" +dependencies = [ + "windows-sys 0.61.2", +] + +[[package]] +name = "combine" +version = "4.6.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cfc320937d09e6de266b31b9afb480f197d7a861be86be7cb2ea7e5d1bfffc5e" +dependencies = [ + "bytes", + "memchr", +] + +[[package]] +name = "common_traits" +version = "0.11.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fda9ae1f26adcae83adb2e92f69cf59421f2a277a942f49f8e59f2fcbd7cf062" +dependencies = [ + "anyhow", + "half", + "impl-tools 0.10.3", +] + +[[package]] +name = "common_traits" +version = "0.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d8e0d7d0c5977b1e87f759d406740c38227125f374f54d81bc197e877f2c5f26" +dependencies = [ + "anyhow", + "half", + "impl-tools 0.12.0", +] + +[[package]] +name = "console" +version = "0.16.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e96a4956774c13c126a8b5af4daa79384f4d826534c95a02d76afb39e2ab64e3" +dependencies = [ + "encode_unicode", + "libc", + "unicode-width", + "windows-sys 0.61.2", +] + +[[package]] +name = "const-oid" +version = "0.10.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a6ef517f0926dd24a1582492c791b6a4818a4d94e789a334894aa15b0d12f55c" + +[[package]] +name = "convert_case" +version = "0.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "633458d4ef8c78b72454de2d54fd6ab2e60f9e02be22f3c6104cdc8a4e0fceb9" +dependencies = [ + "unicode-segmentation", +] + +[[package]] +name = "core-foundation" +version = "0.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b2a6cd9ae233e7f62ba4e9353e81a88df7fc8a5987b8d445b4d90c879bd156f6" +dependencies = [ + "core-foundation-sys", + "libc", +] + +[[package]] +name = "core-foundation-sys" +version = "0.8.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b" + +[[package]] +name = "cpufeatures" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280" +dependencies = [ + "libc", +] + +[[package]] +name = "cpufeatures" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5ca28b0ae3115b884660db4118d803791fd6756b6e88f39c0f3f7859060d7566" +dependencies = [ + "libc", +] + +[[package]] +name = "crc32fast" +version = "1.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "01a7799fd6b852db0e61728dde9a204c423b44d689dbd432522543614b490e78" +dependencies = [ + "cfg-if", +] + +[[package]] +name = "criterion" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f2b12d017a929603d80db1831cd3a24082f8137ce19c69e6447f54f5fc8d692f" +dependencies = [ + "anes", + "cast", + "ciborium", + "clap", + "criterion-plot", + "is-terminal", + "itertools 0.10.5", + "num-traits", + "once_cell", + "oorandom", + "plotters", + "rayon", + "regex", + "serde", + "serde_derive", + "serde_json", + "tinytemplate", + "walkdir", +] + +[[package]] +name = "criterion-plot" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6b50826342786a51a89e2da3a28f1c32b06e387201bc2d19791f622c673706b1" +dependencies = [ + "cast", + "itertools 0.10.5", +] + +[[package]] +name = "crossbeam-channel" +version = "0.5.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "98b0cc327b5bc766e7fda9c9260cc0fa81b43a8e240440422dff70788e3f9ef1" +dependencies = [ + "crossbeam-utils", +] + +[[package]] +name = "crossbeam-deque" +version = "0.8.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "622f3fc73690be383c7214310406f28a90e6edeadc3cea882f9d71e495b9711a" +dependencies = [ + "crossbeam-epoch", + "crossbeam-utils", +] + +[[package]] +name = "crossbeam-epoch" +version = "0.9.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dc74980687109a3b14c72fd458107bf0baa1da1a1a805e178d15501ba9b86d9d" +dependencies = [ + "crossbeam-utils", +] + +[[package]] +name = "crossbeam-utils" +version = "0.8.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a31eee39dddec8330830986fcd7625edb5a24ec90ea038215273bbc3adb08ac6" + +[[package]] +name = "crunchy" +version = "0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5" + +[[package]] +name = "crypto-common" +version = "0.1.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a" +dependencies = [ + "generic-array", + "typenum", +] + +[[package]] +name = "crypto-common" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ce6e4c961d6cd6c9a86db418387425e8bdeaf05b3c8bc1411e6dca4c252f1453" +dependencies = [ + "hybrid-array", +] + +[[package]] +name = "derive_more" +version = "2.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d751e9e49156b02b44f9c1815bcb94b984cdcc4396ecc32521c739452808b134" +dependencies = [ + "derive_more-impl", +] + +[[package]] +name = "derive_more-impl" +version = "2.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "799a97264921d8623a957f6c3b9011f3b5492f557bbb7a5a19b7fa6d06ba8dcb" +dependencies = [ + "convert_case", + "proc-macro2", + "quote", + "rustc_version", + "syn 2.0.119", + "unicode-xid", +] + +[[package]] +name = "digest" +version = "0.10.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292" +dependencies = [ + "block-buffer", + "crypto-common 0.1.7", +] + +[[package]] +name = "digest" +version = "0.11.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f1dd6dbb5841937940781866fa1281a1ff7bd3bf827091440879f9994983d5c2" +dependencies = [ + "const-oid", + "crypto-common 0.2.2", +] + +[[package]] +name = "dispatch2" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e0e367e4e7da84520dedcac1901e4da967309406d1e51017ae1abfb97adbd38" +dependencies = [ + "bitflags 2.13.2", + "objc2", +] + +[[package]] +name = "either" +version = "1.19.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0e9c71c2167ca323c882b99918929403426e2373ea17242ff5653e0d5e1058be" + +[[package]] +name = "encode_unicode" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "34aa73646ffb006b8f5147f3dc182bd4bcb190227ce861fc4a4844bf8e3cb2c0" + +[[package]] +name = "enum-as-inner" +version = "0.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a1e6a265c649f3f5979b601d26f1d05ada116434c87741c9493cb56218f76cbc" +dependencies = [ + "heck", + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "epserde" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c40d342ff20a2ce62d9a85ce406e672dfa137f902ac9670034533184f1533976" +dependencies = [ + "anyhow", + "bitflags 2.13.2", + "common_traits 0.11.4", + "epserde-derive 0.8.0", + "maligned", + "mem_dbg 0.3.4", + "mmap-rs 0.6.1", + "sealed", + "thiserror 2.0.21", + "xxhash-rust", +] + +[[package]] +name = "epserde" +version = "0.13.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d6cd9f3212ce43e7b594a974c6e8cef4e11c6473d76b7b97cb01c239130789eb" +dependencies = [ + "aliasable", + "anyhow", + "bitflags 2.13.2", + "epserde-derive 0.13.2", + "maybe-dangling", + "mem_dbg 0.4.4", + "mmap-rs 0.7.0", + "sealed", + "sha2", + "thiserror 2.0.21", +] + +[[package]] +name = "epserde-derive" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac80cc78b69765703f48ad93f33b8919cf5d907cda7459ad6ba2919cbbe605dd" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "epserde-derive" +version = "0.13.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d73e3083270b2ff144c990e26580374fdfd512f61dd5a12da9b5bd749a7585e0" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "equivalent" +version = "1.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "00d174d5400e5e8fd687ad1049e2f578285fa914201b1af7e8b112a4546bd826" + +[[package]] +name = "errno" +version = "0.3.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb" +dependencies = [ + "libc", + "windows-sys 0.61.2", +] + +[[package]] +name = "fastrand" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "da7c62ceae207dd37ea5b845da6a0696c799f85e97da1ab5b7910be3c1c80223" + +[[package]] +name = "filetime" +version = "0.2.29" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5c287a33c7f0a620c38e641e7f60827713987b3c0f26e8ddc9462cc69cf75759" +dependencies = [ + "cfg-if", + "libc", +] + +[[package]] +name = "find-msvc-tools" +version = "0.1.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aedcfb3409746eddb02b9e19ebda1c3394f759a152e48ee875a0844d1b955484" + +[[package]] +name = "flate2" +version = "1.1.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6e634e2e0ebac1ee034020da1ca582e17ffe4e0f5e985823721e168928136dcb" +dependencies = [ + "crc32fast", + "miniz_oxide", + "zlib-rs", +] + +[[package]] +name = "foldhash" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb" + +[[package]] +name = "funty" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c" + +[[package]] +name = "futures-core" +version = "0.3.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "92d699e522242e69e3003b94ecc1f960f3a5e015aa7c5d7486e65ad01dd94f5e" + +[[package]] +name = "futures-task" +version = "0.3.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cd417de3d1d015fc3bfd2b1ea46dfc7bab72ef86f1cc7cc9c78e728b34a6d1fd" + +[[package]] +name = "futures-util" +version = "0.3.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0d50a92467f8ba5dd6e3ee5d4bd04d73ab2e4e1c44474a0674821dfce14b79bc" +dependencies = [ + "futures-core", + "futures-task", + "pin-project-lite", + "slab", +] + +[[package]] +name = "fxhash" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c31b6d751ae2c7f11320402d34e41349dd1016f8d5d45e48c4312bc8625af50c" +dependencies = [ + "byteorder", +] + +[[package]] +name = "generic-array" +version = "0.14.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a" +dependencies = [ + "typenum", + "version_check", +] + +[[package]] +name = "getrandom" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0" +dependencies = [ + "cfg-if", + "libc", + "wasi", +] + +[[package]] +name = "getrandom" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd" +dependencies = [ + "cfg-if", + "libc", + "r-efi 5.3.0", + "wasip2", +] + +[[package]] +name = "getrandom" +version = "0.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "300e883d756b2e4ec94e02791f39b04b522276138852cfc41d9fb7e904106099" +dependencies = [ + "cfg-if", + "libc", + "r-efi 6.0.0", + "rand_core 0.10.1", +] + +[[package]] +name = "half" +version = "2.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b" +dependencies = [ + "cfg-if", + "crunchy", + "zerocopy", +] + +[[package]] +name = "hashbrown" +version = "0.16.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100" +dependencies = [ + "allocator-api2", + "equivalent", + "foldhash", +] + +[[package]] +name = "hashbrown" +version = "0.17.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a" +dependencies = [ + "allocator-api2", + "equivalent", + "foldhash", + "rayon", +] + +[[package]] +name = "heck" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea" + +[[package]] +name = "hermit-abi" +version = "0.5.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e17592d60ebacc7d5e169f4663c5f84f9161cc90328abcfe8456f41e4dfcb284" + +[[package]] +name = "http" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "918d3568bebf352712bc2ef3d46a8bcf1a75b373be6539de198e9105cbbf9ce0" +dependencies = [ + "bytes", + "itoa", +] + +[[package]] +name = "httparse" +version = "1.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87" + +[[package]] +name = "hwlocality" +version = "1.0.0-alpha.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "675f669dc152dbbbdf9cc9602192262e2ff465c822d32bb937157c5300d5d61f" +dependencies = [ + "arrayvec", + "bitflags 2.13.2", + "derive_more", + "errno", + "hwlocality-sys", + "libc", + "strum", + "thiserror 2.0.21", + "windows-sys 0.61.2", +] + +[[package]] +name = "hwlocality-sys" +version = "0.7.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e6a8feaeb431a8d8d4f163456e9b5bc7b18bc30c576360d2da2c04990da2f357" +dependencies = [ + "autotools", + "cmake", + "flate2", + "libc", + "pkg-config", + "sha3", + "tar", + "ureq", + "windows-sys 0.61.2", +] + +[[package]] +name = "hybrid-array" +version = "0.4.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "27f864f10dfb56725ce5ce5472bc52252c8f93a4ab86327122cebf62c5f59a17" +dependencies = [ + "typenum", +] + +[[package]] +name = "impl-tools" +version = "0.10.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0ae95c9095c2f1126d7db785955c73cdc5fc33e7c3fa911bd4a42931672029a7" +dependencies = [ + "autocfg", + "impl-tools-lib 0.11.4", + "proc-macro-error2", + "syn 2.0.119", +] + +[[package]] +name = "impl-tools" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "06c8567c75b167cdda5ecee024da9cc9581d41bd52460e2e0e768967972aeef1" +dependencies = [ + "autocfg", + "impl-tools-lib 0.12.0", + "proc-macro-error3", + "syn 2.0.119", +] + +[[package]] +name = "impl-tools-lib" +version = "0.11.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ab699036df31c1f7d3561bfa6e9cb9bc3bb0fd2e2cd9bf121c31cb961d049ddf" +dependencies = [ + "proc-macro-error2", + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "impl-tools-lib" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c81eb99ba7c6145aeccb8857ddc0c611cd52440091dcfddd605b6a930c9afbf4" +dependencies = [ + "proc-macro-error3", + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "indicatif" +version = "0.18.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9433806cd6b4ec1aba79c021c7e4c58fb4c3b9977c085062e611ac929998fb0c" +dependencies = [ + "console", + "portable-atomic", + "unicode-width", + "unit-prefix", + "web-time", +] + +[[package]] +name = "is-terminal" +version = "0.4.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3640c1c38b8e4e43584d8df18be5fc6b0aa314ce6ebf51b53313d4306cca8e46" +dependencies = [ + "hermit-abi", + "libc", + "windows-sys 0.61.2", +] + +[[package]] +name = "is_terminal_polyfill" +version = "1.70.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a6cb138bb79a146c1bd460005623e142ef0181e3d0219cb493e02f7d08a35695" + +[[package]] +name = "itertools" +version = "0.10.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473" +dependencies = [ + "either", +] + +[[package]] +name = "itertools" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2b192c782037fadd9cfa75548310488aabdbf3d2da73885b31bd0abd03351285" +dependencies = [ + "either", +] + +[[package]] +name = "itertools" +version = "0.15.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8b4baf93f58d4425749ca49a51c50ebab072c5df6994d08fed93541c331481dc" +dependencies = [ + "either", +] + +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + +[[package]] +name = "jni" +version = "0.22.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5efd9a482cf3a427f00d6b35f14332adc7902ce91efb778580e180ff90fa3498" +dependencies = [ + "cfg-if", + "combine", + "jni-macros", + "jni-sys", + "log", + "simd_cesu8", + "thiserror 2.0.21", + "walkdir", + "windows-link", +] + +[[package]] +name = "jni-macros" +version = "0.22.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a00109accc170f0bdb141fed3e393c565b6f5e072365c3bd58f5b062591560a3" +dependencies = [ + "proc-macro2", + "quote", + "rustc_version", + "simd_cesu8", + "syn 2.0.119", +] + +[[package]] +name = "jni-sys" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c6377a88cb3910bee9b0fa88d4f42e1d2da8e79915598f65fb0c7ee14c878af2" +dependencies = [ + "jni-sys-macros", +] + +[[package]] +name = "jni-sys-macros" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "38c0b942f458fe50cdac086d2f946512305e5631e720728f2a61aabcd47a6264" +dependencies = [ + "quote", + "syn 2.0.119", +] + +[[package]] +name = "jobserver" +version = "0.1.35" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1c00acbd29eabad4a2392fa0e921c874934dbbf4194312ad20f04a0ed67a3cb3" +dependencies = [ + "getrandom 0.4.3", + "libc", +] + +[[package]] +name = "js-sys" +version = "0.3.106" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7883d941dae510fb2d978fc3fe018c71c9e2892fd38854de3e8b92c2e5ad9cc5" +dependencies = [ + "cfg-if", + "futures-util", + "wasm-bindgen", +] + +[[package]] +name = "keccak" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d8f198d1db720e4940b5a493201d199d9f24f568f8f746bd13706243a2f71598" +dependencies = [ + "cfg-if", + "cpufeatures 0.3.1", +] + +[[package]] +name = "lazy_static" +version = "1.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "20870f649af7073d53e38067b2a84312175d56ea15217e1b15bc83506ec50afb" + +[[package]] +name = "libbz2-rs-sys" +version = "0.2.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "34b357333733e8260735ba5894eb928c02ecc69c78715f01a8019e7fa7f2db4c" + +[[package]] +name = "libc" +version = "0.2.190" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ce5d3ddc6d3fa000eb1536d85e147bfe31aacaba692ed6a876f95cb7c855be78" + +[[package]] +name = "liblzma" +version = "0.4.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2fe0a34ca854fd4f20c07f696fc8675aec78f87d88d29f5e10257a7490a1b2e1" +dependencies = [ + "liblzma-sys", +] + +[[package]] +name = "liblzma-sys" +version = "0.4.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7c7e3581f367a78d7b7e7ae948d023310556f0cfc13156c2e4e00e25616492b9" +dependencies = [ + "cc", + "libc", + "pkg-config", +] + +[[package]] +name = "linux-raw-sys" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53" + +[[package]] +name = "log" +version = "0.4.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f9f8bd3e56ce4dfc153cf470fffbfa98c7620958b312ca5c3a4b8d5181fd13c6" + +[[package]] +name = "lru" +version = "0.18.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ef9ac18847474e638e3702b76c65d4eb93428471a74778ef0f1be711717f89b5" +dependencies = [ + "hashbrown 0.17.1", +] + +[[package]] +name = "mach2" +version = "0.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d640282b302c0bb0a2a8e0233ead9035e3bed871f0b7e81fe4a1ec829765db44" +dependencies = [ + "libc", +] + +[[package]] +name = "maligned" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7e88c3cbe8288f77f293e48a28b3232e3defd203a6d839fa7f68ea4329e83464" + +[[package]] +name = "matchers" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d1525a2a28c7f4fa0fc98bb91ae755d1e2d1505079e05539e35bc876b5d65ae9" +dependencies = [ + "regex-automata", +] + +[[package]] +name = "matrixmultiply" +version = "0.3.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f607c237553f086e7043417a51df26b2eb899d3caff94e6a67592ff992fedc7" +dependencies = [ + "autocfg", + "rawpointer", +] + +[[package]] +name = "maybe-dangling" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "59dbb09ed53f8e4f314e353dc6c1853ae5b4c480a668a422657804a544ea9f65" + +[[package]] +name = "mem_dbg" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "728cc9dc97593cd22f7bc81fbef70a2d391d7a9a855e7d658b653318124a6cf0" +dependencies = [ + "bitflags 2.13.2", + "maligned", + "mem_dbg-derive 0.2.1", + "mmap-rs 0.6.1", +] + +[[package]] +name = "mem_dbg" +version = "0.4.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b48a1086c746f4ee6ca5cb0acf856a14709bc4d2d20e03db150a12ddf2269e6d" +dependencies = [ + "aliasable", + "bitflags 2.13.2", + "hashbrown 0.16.1", + "maybe-dangling", + "mem_dbg-derive 0.3.4", + "mmap-rs 0.7.0", +] + +[[package]] +name = "mem_dbg-derive" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d84f40c93b0508d5565db79a814d02d5b2545967205ce44be211592aafa34d6c" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "mem_dbg-derive" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eb910efe8da52f13da727170e352e50a1764579a6fb1065d00d9556da19c79ac" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "memchr" +version = "2.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98" + +[[package]] +name = "memmap2" +version = "0.9.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d1219ed1b7f229ee7104d281dd01d6802fe28bb6e95d292942c4daacdeb798c0" +dependencies = [ + "libc", +] + +[[package]] +name = "memoffset" +version = "0.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5de893c32cde5f383baa4c04c5d6dbdd735cfd4a794b0debdb2bb1b421da5ff4" +dependencies = [ + "autocfg", +] + +[[package]] +name = "migrate-mphf" +version = "0.1.0" +dependencies = [ + "anyhow", + "cacheline-ef 1.1.0", + "clap", + "epserde 0.13.2", + "epserde 0.8.0", + "obicompactvec", + "obikindex", + "obiskio", + "obisys", + "ptr_hash 1.1.0", + "rayon", + "tracing", + "tracing-subscriber", +] + +[[package]] +name = "miniz_oxide" +version = "0.9.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b63fbc4a50860e98e7b2aa7804ded1db5cbc3aff9193adaff57a6931bf7c4b4c" +dependencies = [ + "adler2", + "simd-adler32", +] + +[[package]] +name = "mmap-rs" +version = "0.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "86968d85441db75203c34deefd0c88032f275aaa85cee19a1dcfff6ae9df56da" +dependencies = [ + "bitflags 1.3.2", + "combine", + "libc", + "mach2", + "nix 0.26.4", + "sysctl 0.5.5", + "thiserror 1.0.69", + "widestring", + "windows 0.48.0", +] + +[[package]] +name = "mmap-rs" +version = "0.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4ecce9d566cb9234ae3db9e249c8b55665feaaf32b0859ff1e27e310d2beb3d8" +dependencies = [ + "bitflags 2.13.2", + "combine", + "libc", + "mach2", + "nix 0.30.1", + "sysctl 0.6.0", + "thiserror 2.0.21", + "widestring", + "windows 0.48.0", +] + +[[package]] +name = "nanorand" +version = "0.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "729eb334247daa1803e0a094d0a5c55711b85571179f5ec6e53eccfdf7008958" + +[[package]] +name = "ndarray" +version = "0.17.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "520080814a7a6b4a6e9070823bb24b4531daac8c4627e08ba5de8c5ef2f2752d" +dependencies = [ + "matrixmultiply", + "num-complex", + "num-integer", + "num-traits", + "portable-atomic", + "portable-atomic-util", + "rawpointer", +] + +[[package]] +name = "niffler" +version = "3.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "01baa3696744e580712b28344fe25ed4ac1e8c4b76cc5189a34e713924c25208" +dependencies = [ + "bgzip", + "bzip2", + "cfg-if", + "flate2", + "liblzma", + "thiserror 2.0.21", + "zstd", +] + +[[package]] +name = "nix" +version = "0.26.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "598beaf3cc6fdd9a5dfb1630c2800c7acd31df7aaf0f565796fba2b53ca1af1b" +dependencies = [ + "bitflags 1.3.2", + "cfg-if", + "libc", + "memoffset", + "pin-utils", +] + +[[package]] +name = "nix" +version = "0.30.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "74523f3a35e05aba87a1d978330aef40f67b0304ac79c1c00b294c9830543db6" +dependencies = [ + "bitflags 2.13.2", + "cfg-if", + "cfg_aliases", + "libc", +] + +[[package]] +name = "ntapi" +version = "0.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c3b335231dfd352ffb0f8017f3b6027a4917f7df785ea2143d8af2adc66980ae" +dependencies = [ + "winapi", +] + +[[package]] +name = "nu-ansi-term" +version = "0.50.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5" +dependencies = [ + "windows-sys 0.61.2", +] + +[[package]] +name = "num-complex" +version = "0.4.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "73f88a1307638156682bada9d7604135552957b7818057dcef22705b4d509495" +dependencies = [ + "num-traits", +] + +[[package]] +name = "num-integer" +version = "0.1.47" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7ce2d95d4b3734dc35aa2f45e1aa22cd416814592a4f9d9205e11affd5b8e10b" +dependencies = [ + "num-traits", +] + +[[package]] +name = "num-traits" +version = "0.2.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841" +dependencies = [ + "autocfg", +] + +[[package]] +name = "obicompactvec" +version = "0.1.0" +dependencies = [ + "common_traits 0.13.0", + "memmap2", + "ndarray", + "rayon", + "tempfile", +] + +[[package]] +name = "obidebruinj" +version = "0.1.0" +dependencies = [ + "ahash", + "crossbeam-channel", + "hashbrown 0.17.1", + "obifastwrite", + "obikseq", + "rayon", + "tracing", + "xxhash-rust", +] + +[[package]] +name = "obifastwrite" +version = "0.1.0" +dependencies = [ + "obikseq", + "xxhash-rust", +] + +[[package]] +name = "obikentropy" +version = "0.1.0" +dependencies = [ + "obikseq", +] + +[[package]] +name = "obikindex" +version = "0.1.0" +dependencies = [ + "bitvec", + "cacheline-ef 2.0.0", + "epserde 0.13.2", + "indicatif", + "memmap2", + "ndarray", + "niffler", + "obicompactvec", + "obidebruinj", + "obikentropy", + "obikseq", + "obipipeline", + "obiskio", + "obisys", + "obitaxonomy", + "ptr_hash 2.1.2", + "rayon", + "serde", + "serde_json", + "tracing", +] + +[[package]] +name = "obikseq" +version = "0.1.0" +dependencies = [ + "bitvec", + "serde", + "serde_json", + "xxhash-rust", +] + +[[package]] +name = "obipipeline" +version = "0.1.0" +dependencies = [ + "crossbeam-channel", +] + +[[package]] +name = "obiskio" +version = "0.1.0" +dependencies = [ + "lru", + "memmap2", + "niffler", + "obikseq", + "rustix", + "serde", + "serde_json", +] + +[[package]] +name = "obisys" +version = "0.1.0" +dependencies = [ + "crossbeam-channel", + "hwlocality", + "indicatif", + "libc", + "rayon", + "sysinfo", + "tracing", +] + +[[package]] +name = "obitaxonomy" +version = "0.1.0" + +[[package]] +name = "objc2" +version = "0.6.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "08849bbd4767dfae9457696856ae1c84fe4e0281bbe4a7abff2d0e06fb7981f8" +dependencies = [ + "objc2-encode", +] + +[[package]] +name = "objc2-core-foundation" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2a180dd8642fa45cdb7dd721cd4c11b1cadd4929ce112ebd8b9f5803cc79d536" +dependencies = [ + "bitflags 2.13.2", + "dispatch2", + "objc2", +] + +[[package]] +name = "objc2-encode" +version = "4.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ef25abbcd74fb2609453eb695bd2f860d389e457f67dc17cafc8b8cbc89d0c33" + +[[package]] +name = "objc2-foundation" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e3e0adef53c21f888deb4fa59fc59f7eb17404926ee8a6f59f5df0fd7f9f3272" +dependencies = [ + "bitflags 2.13.2", + "objc2", +] + +[[package]] +name = "objc2-io-kit" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "33fafba39597d6dc1fb709123dfa8289d39406734be322956a69f0931c73bb15" +dependencies = [ + "libc", + "objc2-core-foundation", +] + +[[package]] +name = "objc2-open-directory" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bb82bed227edf5201dfedf072bba4015a33d3d4a98519837295a90f0a23f676d" +dependencies = [ + "objc2", + "objc2-core-foundation", + "objc2-foundation", +] + +[[package]] +name = "once_cell" +version = "1.21.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50" + +[[package]] +name = "once_cell_polyfill" +version = "1.70.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe" + +[[package]] +name = "oorandom" +version = "11.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d6790f58c7ff633d8771f42965289203411a5e5c68388703c06e14f24770b41e" + +[[package]] +name = "openssl-probe" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7c87def4c32ab89d880effc9e097653c8da5d6ef28e6b539d313baaacfbafcbe" + +[[package]] +name = "partition" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "947f833aaa585cf12b8ec7c0476c98784c49f33b861376ffc84ed92adebf2aba" + +[[package]] +name = "percent-encoding" +version = "2.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220" + +[[package]] +name = "pin-project-lite" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd" + +[[package]] +name = "pin-utils" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "13bee6c73da26345c729282832b60b0363cf3dd9f4bfd81d8551b7a1c889a113" + +[[package]] +name = "pkg-config" +version = "0.3.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f6b464fbc74e149a392436b17d523f769e057cb6877f6a5c4618bc6f11800548" + +[[package]] +name = "plotters" +version = "0.3.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5aeb6f403d7a4911efb1e33402027fc44f29b5bf6def3effcc22d7bb75f2b747" +dependencies = [ + "num-traits", + "plotters-backend", + "plotters-svg", + "wasm-bindgen", + "web-sys", +] + +[[package]] +name = "plotters-backend" +version = "0.3.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "df42e13c12958a16b3f7f4386b9ab1f3e7933914ecea48da7139435263a4172a" + +[[package]] +name = "plotters-svg" +version = "0.3.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "51bae2ac328883f7acdfea3d66a7c35751187f870bc81f94563733a154d7a670" +dependencies = [ + "plotters-backend", +] + +[[package]] +name = "portable-atomic" +version = "1.15.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "05c8b63e8d9609db387f0324918f81d68fe27748f084ef092fb35954d0539a85" + +[[package]] +name = "portable-atomic-util" +version = "0.2.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "10ab3eb7f3becc3a1cbc4f2c6f20267996cfc1a6467a873763411b136a122715" +dependencies = [ + "portable-atomic", +] + +[[package]] +name = "ppv-lite86" +version = "0.2.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9" +dependencies = [ + "zerocopy", +] + +[[package]] +name = "prefetch-index" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9057806a8d77d67bccdc0f542db43737a6f19ada3efab2adc63277feea27310f" + +[[package]] +name = "proc-macro-error-attr2" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "96de42df36bb9bba5542fe9f1a054b8cc87e172759a1868aa05c1f3acc89dfc5" +dependencies = [ + "proc-macro2", + "quote", +] + +[[package]] +name = "proc-macro-error-attr3" +version = "3.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9e564d14133360e1ae169ffde5da25881b5fa47261665b8e5713c212c27799da" +dependencies = [ + "proc-macro2", + "quote", +] + +[[package]] +name = "proc-macro-error2" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "11ec05c52be0a07b08061f7dd003e7d7092e0472bc731b4af7bb1ef876109802" +dependencies = [ + "proc-macro-error-attr2", + "proc-macro2", + "quote", +] + +[[package]] +name = "proc-macro-error3" +version = "3.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f0d4471b3436c22106b21913b1dda531558918ae9b7ec55d58aa84b43552233" +dependencies = [ + "proc-macro-error-attr3", + "proc-macro2", + "quote", +] + +[[package]] +name = "proc-macro2" +version = "1.0.107" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "ptr_hash" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4b4e4fb9c4c2ba3e5b060f53ef46afd3de37345b08e3ec0f2c65e0ca1d57ccbd" +dependencies = [ + "anyhow", + "bitvec", + "cacheline-ef 1.1.0", + "clap", + "colored", + "common_traits 0.11.4", + "epserde 0.8.0", + "epserde-derive 0.8.0", + "fastrand", + "fxhash", + "itertools 0.14.0", + "lazy_static", + "log", + "mem_dbg 0.3.4", + "rand 0.9.5", + "rand_chacha 0.9.0", + "rayon", + "rdst", + "rustc-hash", + "serde", + "sucds", + "tempfile", + "xxhash-rust", +] + +[[package]] +name = "ptr_hash" +version = "2.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b22cf1be774892680e056d3387db0dcaa4fd46964b270671ef661e127186b969" +dependencies = [ + "bitvec", + "cacheline-ef 2.0.0", + "colored", + "epserde 0.13.2", + "epserde-derive 0.13.2", + "fastrand", + "fxhash", + "itertools 0.15.0", + "log", + "mem_dbg 0.4.4", + "prefetch-index", + "rand 0.10.3", + "rand_chacha 0.10.0", + "rayon", + "rdst", + "sucds", + "tempfile", + "xxhash-rust", +] + +[[package]] +name = "quote" +version = "1.0.47" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "r-efi" +version = "5.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f" + +[[package]] +name = "r-efi" +version = "6.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf" + +[[package]] +name = "radium" +version = "0.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09" + +[[package]] +name = "rand" +version = "0.9.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b9ef1d0d795eb7d84685bca4f72f3649f064e6641543d3a8c415898726a57b41" +dependencies = [ + "rand_chacha 0.9.0", + "rand_core 0.9.5", +] + +[[package]] +name = "rand" +version = "0.10.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "65c9fb96cbc91e3478eaae79a69fcd3f1ae4ad052e471fe6732fff548984b4af" +dependencies = [ + "chacha20", + "getrandom 0.4.3", + "rand_core 0.10.1", +] + +[[package]] +name = "rand_chacha" +version = "0.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb" +dependencies = [ + "ppv-lite86", + "rand_core 0.9.5", +] + +[[package]] +name = "rand_chacha" +version = "0.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3e6af7f3e25ded52c41df4e0b1af2d047e45896c2f3281792ed68a1c243daedb" +dependencies = [ + "ppv-lite86", + "rand_core 0.10.1", +] + +[[package]] +name = "rand_core" +version = "0.9.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "76afc826de14238e6e8c374ddcc1fa19e374fd8dd986b0d2af0d02377261d83c" +dependencies = [ + "getrandom 0.3.4", +] + +[[package]] +name = "rand_core" +version = "0.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "63b8176103e19a2643978565ca18b50549f6101881c443590420e4dc998a3c69" + +[[package]] +name = "rawpointer" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "60a357793950651c4ed0f3f52338f53b2f809f32d83a07f72909fa13e4c6c1e3" + +[[package]] +name = "rayon" +version = "1.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fb39b166781f92d482534ef4b4b1b2568f42613b53e5b6c160e24cfbfa30926d" +dependencies = [ + "either", + "rayon-core", +] + +[[package]] +name = "rayon-core" +version = "1.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "22e18b0f0062d30d4230b2e85ff77fdfe4326feb054b9783a3460d8435c8ab91" +dependencies = [ + "crossbeam-deque", + "crossbeam-utils", +] + +[[package]] +name = "rdst" +version = "0.20.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6e7970b4e577b76a96d5e56b5f6662b66d1a4e1f5bb026ee118fc31b373c2752" +dependencies = [ + "arbitrary-chunks", + "block-pseudorand", + "criterion", + "partition", + "rayon", + "tikv-jemallocator", + "voracious_radix_sort", +] + +[[package]] +name = "regex" +version = "1.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f020237b6c8eed93db2e2cb53c00c60a8e1bc73da7d073199a1180401450218d" +dependencies = [ + "aho-corasick", + "memchr", + "regex-automata", + "regex-syntax", +] + +[[package]] +name = "regex-automata" +version = "0.4.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ad8553b9b26413251cbf30e620595c7a41b3887f03da04579c0e6b0d6a06b4b2" +dependencies = [ + "aho-corasick", + "memchr", + "regex-syntax", +] + +[[package]] +name = "regex-syntax" +version = "0.8.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4" + +[[package]] +name = "ring" +version = "0.17.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a4689e6c2294d81e88dc6261c768b63bc4fcdb852be6d1352498b114f61383b7" +dependencies = [ + "cc", + "cfg-if", + "getrandom 0.2.17", + "libc", + "untrusted", + "windows-sys 0.52.0", +] + +[[package]] +name = "rustc-hash" +version = "2.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6b1e7f9a428571be2dc5bc0505c13fb6bf936822b894ec87abf8a08a4e51742d" + +[[package]] +name = "rustc_version" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92" +dependencies = [ + "semver", +] + +[[package]] +name = "rustix" +version = "1.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "891efababe418670775f199f0d233d84843c227a0949a883ce15b37c78d6629d" +dependencies = [ + "bitflags 2.13.2", + "errno", + "libc", + "linux-raw-sys", + "windows-sys 0.61.2", +] + +[[package]] +name = "rustls" +version = "0.23.46" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "48e13bd8c0e9365c43cfa5c9e8f9ad49d3c8444926c9aac819e0e4dc503c8fdf" +dependencies = [ + "log", + "once_cell", + "ring", + "rustls-pki-types", + "rustls-webpki", + "subtle", + "zeroize", +] + +[[package]] +name = "rustls-native-certs" +version = "0.8.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4a073f5dc7469f984c52ad2752b63b0807745133b6de880b7b64c1ac4c48aec4" +dependencies = [ + "openssl-probe", + "rustls-pki-types", + "schannel", + "security-framework", +] + +[[package]] +name = "rustls-pki-types" +version = "1.15.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2f4925028c7eb5d1fcdaf196971378ed9d2c1c4efc7dc5d011256f76c99c0a96" +dependencies = [ + "zeroize", +] + +[[package]] +name = "rustls-platform-verifier" +version = "0.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1167586491e2b18b8bfbb293e8180ec17c201c4f076d7cb3070ca964e7598f98" +dependencies = [ + "core-foundation", + "core-foundation-sys", + "jni", + "log", + "once_cell", + "rustls", + "rustls-native-certs", + "rustls-platform-verifier-android", + "rustls-webpki", + "security-framework", + "security-framework-sys", + "webpki-root-certs", + "windows-sys 0.61.2", +] + +[[package]] +name = "rustls-platform-verifier-android" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eec689c0bc40ff2458a5977b6619cb718087084a18e02a131c599b62d05e1a5f" + +[[package]] +name = "rustls-webpki" +version = "0.103.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f3c3cf1d8b1e7d4927e2d154c3fcb02979afb9939629c62cd9048d4f07b60ac2" +dependencies = [ + "ring", + "rustls-pki-types", + "untrusted", +] + +[[package]] +name = "rustversion" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf54715a573b99ac80df0bc206da022bcd442c974952c7b9720069370852e21f" + +[[package]] +name = "same-file" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502" +dependencies = [ + "winapi-util", +] + +[[package]] +name = "schannel" +version = "0.1.29" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "91c1b7e4904c873ef0710c1f407dde2e6287de2bebc1bbbf7d430bb7cbffd939" +dependencies = [ + "windows-sys 0.61.2", +] + +[[package]] +name = "sealed" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "22f968c5ea23d555e670b449c1c5e7b2fc399fdaec1d304a17cd48e288abc107" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "security-framework" +version = "3.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b7f4bc775c73d9a02cde8bf7b2ec4c9d12743edf609006c7facc23998404cd1d" +dependencies = [ + "bitflags 2.13.2", + "core-foundation", + "core-foundation-sys", + "libc", + "security-framework-sys", +] + +[[package]] +name = "security-framework-sys" +version = "2.17.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6ce2691df843ecc5d231c0b14ece2acc3efb62c0a398c7e1d875f3983ce020e3" +dependencies = [ + "core-foundation-sys", + "libc", +] + +[[package]] +name = "semver" +version = "1.0.28" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd" + +[[package]] +name = "serde" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba" +dependencies = [ + "serde_core", + "serde_derive", +] + +[[package]] +name = "serde_core" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "67dca2c9c51e58a4791a4b1ed58308b39c64224d349a935ab5039aa360942a48" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde_derive" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.9", +] + +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + +[[package]] +name = "sha2" +version = "0.10.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283" +dependencies = [ + "cfg-if", + "cpufeatures 0.2.17", + "digest 0.10.7", +] + +[[package]] +name = "sha3" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bc9bad02c26382724b2d2692c6f179285e4b54eeecd7968f52a50059c3c11759" +dependencies = [ + "digest 0.11.3", + "keccak", + "sponge-cursor", +] + +[[package]] +name = "sharded-slab" +version = "0.1.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f40ca3c46823713e0d4209592e8d6e826aa57e928f09752619fc696c499637f6" +dependencies = [ + "lazy_static", +] + +[[package]] +name = "shlex" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba" + +[[package]] +name = "simd-adler32" +version = "0.3.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3a219298ac11a56ea9a6d2120044824d6f01aeb034955e7af7bc16858527deea" + +[[package]] +name = "simd_cesu8" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "11031e251abf8611c80f460e19dbdeb54a66db918e49c65a7065b46ac7aec520" +dependencies = [ + "rustc_version", + "simdutf8", +] + +[[package]] +name = "simdutf8" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e3a9fe34e3e7a50316060351f37187a3f546bce95496156754b601a5fa71b76e" + +[[package]] +name = "slab" +version = "0.4.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5" + +[[package]] +name = "smallvec" +version = "1.16.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5b3dc8af474f516a851ff4bd12db780f948b9250ad37211e4eec0bccea54e01b" + +[[package]] +name = "sponge-cursor" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3a0219bd7d979d58245a4f41f695e1ac9f8befdffadd7f61f1bae9e39abc6620" + +[[package]] +name = "strsim" +version = "0.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f" + +[[package]] +name = "strum" +version = "0.28.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9628de9b8791db39ceda2b119bbe13134770b56c138ec1d3af810d045c04f9bd" +dependencies = [ + "strum_macros", +] + +[[package]] +name = "strum_macros" +version = "0.28.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ab85eea0270ee17587ed4156089e10b9e6880ee688791d45a905f5b1ca36f664" +dependencies = [ + "heck", + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "subtle" +version = "2.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292" + +[[package]] +name = "sucds" +version = "0.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cd324eaa05be64f105ea5269bb8aabd70e5dd57fa5c673b167f451b07d6c0dcd" +dependencies = [ + "anyhow", + "num-traits", +] + +[[package]] +name = "syn" +version = "2.0.119" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "872831b642d1a07999a962a351ed35b955ea2cfc8f3862091e2a240a84f17297" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "syn" +version = "3.0.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d78c8dee4c7bf0e14673097256fed6142ce9d3b85a408189d07482442145823b" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "sysctl" +version = "0.5.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec7dddc5f0fee506baf8b9fdb989e242f17e4b11c61dfbb0635b705217199eea" +dependencies = [ + "bitflags 2.13.2", + "byteorder", + "enum-as-inner", + "libc", + "thiserror 1.0.69", + "walkdir", +] + +[[package]] +name = "sysctl" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "01198a2debb237c62b6826ec7081082d951f46dbb64b0e8c7649a452230d1dfc" +dependencies = [ + "bitflags 2.13.2", + "byteorder", + "enum-as-inner", + "libc", + "thiserror 1.0.69", + "walkdir", +] + +[[package]] +name = "sysinfo" +version = "0.39.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d2071df9448915b71c4fe6d25deaf1c22f12bd234f01540b77312bb8e41361e6" +dependencies = [ + "libc", + "memchr", + "ntapi", + "objc2-core-foundation", + "objc2-io-kit", + "objc2-open-directory", + "windows 0.62.2", +] + +[[package]] +name = "tap" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369" + +[[package]] +name = "tar" +version = "0.4.46" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f6221d9a6003c78398e3b239969f352578258df48c8eb051caadae0015bc840" +dependencies = [ + "filetime", + "libc", + "xattr", +] + +[[package]] +name = "tempfile" +version = "3.27.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd" +dependencies = [ + "fastrand", + "getrandom 0.4.3", + "once_cell", + "rustix", + "windows-sys 0.61.2", +] + +[[package]] +name = "thiserror" +version = "1.0.69" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52" +dependencies = [ + "thiserror-impl 1.0.69", +] + +[[package]] +name = "thiserror" +version = "2.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09e52cb86a36cede5cb101bf8908837b3e4c6e5e59fe7fd85c23fb56200d189e" +dependencies = [ + "thiserror-impl 2.0.21", +] + +[[package]] +name = "thiserror-impl" +version = "1.0.69" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "thiserror-impl" +version = "2.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fe5197923287db20a58125f0bc85c062f7f2c892de97b18c356f9efb14b28524" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.9", +] + +[[package]] +name = "thread_local" +version = "1.1.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1ad99c4c6d32803332c548b1af0540b357b3f5fc0be8f6c6bfe8b2e6ae784070" +dependencies = [ + "cfg-if", +] + +[[package]] +name = "tikv-jemalloc-sys" +version = "0.5.4+5.3.0-patched" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9402443cb8fd499b6f327e40565234ff34dbda27460c5b47db0db77443dd85d1" +dependencies = [ + "cc", + "libc", +] + +[[package]] +name = "tikv-jemallocator" +version = "0.5.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "965fe0c26be5c56c94e38ba547249074803efd52adfb66de62107d95aab3eaca" +dependencies = [ + "libc", + "tikv-jemalloc-sys", +] + +[[package]] +name = "tinytemplate" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "be4d6b5f19ff7664e8c98d03e2139cb510db9b0a60b55f8e8709b689d939b6bc" +dependencies = [ + "serde", + "serde_json", +] + +[[package]] +name = "tracing" +version = "0.1.44" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100" +dependencies = [ + "pin-project-lite", + "tracing-attributes", + "tracing-core", +] + +[[package]] +name = "tracing-attributes" +version = "0.1.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7490cfa5ec963746568740651ac6781f701c9c5ea257c58e057f3ba8cf69e8da" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "tracing-core" +version = "0.1.36" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a" +dependencies = [ + "once_cell", + "valuable", +] + +[[package]] +name = "tracing-log" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ee855f1f400bd0e5c02d150ae5de3840039a3f54b025156404e34c23c03f47c3" +dependencies = [ + "log", + "once_cell", + "tracing-core", +] + +[[package]] +name = "tracing-subscriber" +version = "0.3.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cb7f578e5945fb242538965c2d0b04418d38ec25c79d160cd279bf0731c8d319" +dependencies = [ + "matchers", + "nu-ansi-term", + "once_cell", + "regex-automata", + "sharded-slab", + "smallvec", + "thread_local", + "tracing", + "tracing-core", + "tracing-log", +] + +[[package]] +name = "typenum" +version = "1.20.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6f5e870be6c3b371b77fe0ee0bafb859fa4964b4404c27de1d380043c4dda20" + +[[package]] +name = "unicode-ident" +version = "1.0.27" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a2c754d6c33795a1c324727428e5a7dedb5b06195f9890bdbcba760d3e246563" + +[[package]] +name = "unicode-segmentation" +version = "1.13.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c6f5d3c3b1bf09027a88a6bc961fc00497d651009560b5463668dc81b0fa87a8" + +[[package]] +name = "unicode-width" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b4ac048d71ede7ee76d585517add45da530660ef4390e49b098733c6e897f254" + +[[package]] +name = "unicode-xid" +version = "0.2.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853" + +[[package]] +name = "unit-prefix" +version = "0.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "81e544489bf3d8ef66c953931f56617f423cd4b5494be343d9b9d3dda037b9a3" + +[[package]] +name = "untrusted" +version = "0.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1" + +[[package]] +name = "ureq" +version = "3.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9a7ac20be9b7726e0bbdbf974c059676d9acb1cd414961f570a4e8231cacd7fc" +dependencies = [ + "base64", + "flate2", + "log", + "percent-encoding", + "rustls", + "rustls-pki-types", + "rustls-platform-verifier", + "ureq-proto", + "utf8-zero", + "webpki-roots", +] + +[[package]] +name = "ureq-proto" +version = "0.6.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f86fd172ccca569e458f61b6bdd6220965a9ef36e672a6852953b51a0e1583be" +dependencies = [ + "base64", + "http", + "httparse", + "log", +] + +[[package]] +name = "utf8-zero" +version = "0.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b8c0a043c9540bae7c578c88f91dda8bd82e59ae27c21baca69c8b191aaf5a6e" + +[[package]] +name = "utf8parse" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821" + +[[package]] +name = "valuable" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65" + +[[package]] +name = "version_check" +version = "0.9.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a" + +[[package]] +name = "voracious_radix_sort" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "446e7ffcb6c27a71d05af7e51ef2ee5b71c48424b122a832f2439651e1914899" +dependencies = [ + "rayon", +] + +[[package]] +name = "walkdir" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b" +dependencies = [ + "same-file", + "winapi-util", +] + +[[package]] +name = "wasi" +version = "0.11.1+wasi-snapshot-preview1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b" + +[[package]] +name = "wasip2" +version = "1.0.4+wasi-0.2.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b67efb37e106e55ce722a510d6b5f9c17f083e5fc79afc2badeb12cc313d9487" +dependencies = [ + "wit-bindgen", +] + +[[package]] +name = "wasm-bindgen" +version = "0.2.129" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9bb54f33acc68fd454578d9820b0bde1a1a3d17aa17bb7b6595806d02886d409" +dependencies = [ + "cfg-if", + "once_cell", + "rustversion", + "wasm-bindgen-macro", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-macro" +version = "0.2.129" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2e29d0c35b16e224a7eeb5cd2d25e3e1968fbd65604117b44d3b789d00ee8535" +dependencies = [ + "quote", + "wasm-bindgen-macro-support", +] + +[[package]] +name = "wasm-bindgen-macro-support" +version = "0.2.129" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6f501a8bc3719dba86ef8ae4728879c08001bea749eb1333ac5b91e040e2a6b7" +dependencies = [ + "bumpalo", + "proc-macro2", + "quote", + "syn 3.0.9", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-shared" +version = "0.2.129" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "23f0c9c52aa7cd7d77769a4cfe2a9adb1b331f489a41d912ce14513d5ab995c6" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "web-sys" +version = "0.3.106" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "88261b9deccee56594c11a3460c462c41f58d148598fe70ad77070126a68aba4" +dependencies = [ + "js-sys", + "wasm-bindgen", +] + +[[package]] +name = "web-time" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5a6580f308b1fad9207618087a65c04e7a10bc77e02c8e84e9b00dd4b12fa0bb" +dependencies = [ + "js-sys", + "wasm-bindgen", +] + +[[package]] +name = "webpki-root-certs" +version = "1.0.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b96554aa2acc8ccdb7e1c9a58a7a68dd5d13bccc69cd124cb09406db612a1c9b" +dependencies = [ + "rustls-pki-types", +] + +[[package]] +name = "webpki-roots" +version = "1.0.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7dcd9d09a39985f5344844e66b0c530a33843579125f23e21e9f0f220850f22a" +dependencies = [ + "rustls-pki-types", +] + +[[package]] +name = "widestring" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72069c3113ab32ab29e5584db3c6ec55d416895e60715417b5b883a357c3e471" + +[[package]] +name = "winapi" +version = "0.3.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419" +dependencies = [ + "winapi-i686-pc-windows-gnu", + "winapi-x86_64-pc-windows-gnu", +] + +[[package]] +name = "winapi-i686-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" + +[[package]] +name = "winapi-util" +version = "0.1.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22" +dependencies = [ + "windows-sys 0.61.2", +] + +[[package]] +name = "winapi-x86_64-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" + +[[package]] +name = "windows" +version = "0.48.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e686886bc078bc1b0b600cac0147aadb815089b6e4da64016cbd754b6342700f" +dependencies = [ + "windows-targets 0.48.5", +] + +[[package]] +name = "windows" +version = "0.62.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "527fadee13e0c05939a6a05d5bd6eec6cd2e3dbd648b9f8e447c6518133d8580" +dependencies = [ + "windows-collections", + "windows-core", + "windows-future", + "windows-numerics", +] + +[[package]] +name = "windows-collections" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "23b2d95af1a8a14a3c7367e1ed4fc9c20e0a26e79551b1454d72583c97cc6610" +dependencies = [ + "windows-core", +] + +[[package]] +name = "windows-core" +version = "0.62.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb" +dependencies = [ + "windows-implement", + "windows-interface", + "windows-link", + "windows-result", + "windows-strings", +] + +[[package]] +name = "windows-future" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e1d6f90251fe18a279739e78025bd6ddc52a7e22f921070ccdc67dde84c605cb" +dependencies = [ + "windows-core", + "windows-link", + "windows-threading", +] + +[[package]] +name = "windows-implement" +version = "0.60.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "windows-interface" +version = "0.59.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "windows-link" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5" + +[[package]] +name = "windows-numerics" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6e2e40844ac143cdb44aead537bbf727de9b044e107a0f1220392177d15b0f26" +dependencies = [ + "windows-core", + "windows-link", +] + +[[package]] +name = "windows-result" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5" +dependencies = [ + "windows-link", +] + +[[package]] +name = "windows-strings" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091" +dependencies = [ + "windows-link", +] + +[[package]] +name = "windows-sys" +version = "0.52.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d" +dependencies = [ + "windows-targets 0.52.6", +] + +[[package]] +name = "windows-sys" +version = "0.61.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc" +dependencies = [ + "windows-link", +] + +[[package]] +name = "windows-targets" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c" +dependencies = [ + "windows_aarch64_gnullvm 0.48.5", + "windows_aarch64_msvc 0.48.5", + "windows_i686_gnu 0.48.5", + "windows_i686_msvc 0.48.5", + "windows_x86_64_gnu 0.48.5", + "windows_x86_64_gnullvm 0.48.5", + "windows_x86_64_msvc 0.48.5", +] + +[[package]] +name = "windows-targets" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973" +dependencies = [ + "windows_aarch64_gnullvm 0.52.6", + "windows_aarch64_msvc 0.52.6", + "windows_i686_gnu 0.52.6", + "windows_i686_gnullvm", + "windows_i686_msvc 0.52.6", + "windows_x86_64_gnu 0.52.6", + "windows_x86_64_gnullvm 0.52.6", + "windows_x86_64_msvc 0.52.6", +] + +[[package]] +name = "windows-threading" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3949bd5b99cafdf1c7ca86b43ca564028dfe27d66958f2470940f73d86d75b37" +dependencies = [ + "windows-link", +] + +[[package]] +name = "windows_aarch64_gnullvm" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8" + +[[package]] +name = "windows_aarch64_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3" + +[[package]] +name = "windows_aarch64_msvc" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc" + +[[package]] +name = "windows_aarch64_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469" + +[[package]] +name = "windows_i686_gnu" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e" + +[[package]] +name = "windows_i686_gnu" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b" + +[[package]] +name = "windows_i686_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66" + +[[package]] +name = "windows_i686_msvc" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406" + +[[package]] +name = "windows_i686_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78" + +[[package]] +name = "windows_x86_64_gnullvm" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc" + +[[package]] +name = "windows_x86_64_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec" + +[[package]] +name = "wit-bindgen" +version = "0.57.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1ebf944e87a7c253233ad6766e082e3cd714b5d03812acc24c318f549614536e" + +[[package]] +name = "wyz" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "05f360fc0b24296329c78fda852a1e9ae82de9cf7b27dae4b7f62f118f77b9ed" +dependencies = [ + "tap", +] + +[[package]] +name = "xattr" +version = "1.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32e45ad4206f6d2479085147f02bc2ef834ac85886624a23575ae137c8aa8156" +dependencies = [ + "libc", + "rustix", +] + +[[package]] +name = "xxhash-rust" +version = "0.8.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "550a2b930b62486a393c52d5c3b84bff264b28aa437ed64694d31e93b1757af7" + +[[package]] +name = "zerocopy" +version = "0.8.63" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e5fe1f8f1b06191a00962174c61aa5005e0bb391a6d80d07e24d115c01a92ed8" +dependencies = [ + "zerocopy-derive", +] + +[[package]] +name = "zerocopy-derive" +version = "0.8.63" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "863ad3ac83293fb4d740aedbfdc9240dd8d1a50c1099acd76ce80ce7c7230c7f" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "zeroize" +version = "1.9.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e13084392c5e4bc371903e2935a5eaeed24905a7511356b883835e18a78f6879" + +[[package]] +name = "zlib-rs" +version = "0.6.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b268e58e7c693d7c271f93ffc4ba3b380412554231c85bf61ca7af91042a4112" + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" + +[[package]] +name = "zstd" +version = "0.13.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e91ee311a569c327171651566e07972200e76fcfe2242a4fa446149a3881c08a" +dependencies = [ + "zstd-safe", +] + +[[package]] +name = "zstd-safe" +version = "7.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "64d80649ab6db9d9f6f9c80a40becd948eda4714a0a5ac8c4d157a32231c7882" +dependencies = [ + "zstd-sys", +] + +[[package]] +name = "zstd-sys" +version = "2.1.1+zstd.1.5.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aeec9eaf2dffbbd09201e23bd0ffcbaa33bb8e9266a10734fd7ed90a85eca078" +dependencies = [ + "cc", + "pkg-config", +] diff --git a/tools/migrate-mphf/Cargo.toml b/tools/migrate-mphf/Cargo.toml new file mode 100644 index 00000000..4c29297e --- /dev/null +++ b/tools/migrate-mphf/Cargo.toml @@ -0,0 +1,36 @@ +[package] +name = "migrate-mphf" +version = "0.1.0" +edition = "2024" +publish = false +description = "One-shot converter: obikmer indexes whose layer MPHFs were built with ptr_hash 1.x -> ptr_hash 2.x" + +# Standalone: not a member of src/'s workspace, own Cargo.lock. The previous +# generation of the MPHF stack (and its `proc-macro-error2` future-incompat +# warning) lives only here, never in obikmer itself. +[workspace] + +[features] +default = [] +numa = ["obisys/numa"] + +[dependencies] +obikindex = { path = "../../src/obikindex" } +obicompactvec = { path = "../../src/obicompactvec" } +obiskio = { path = "../../src/obiskio" } +obisys = { path = "../../src/obisys", default-features = false } +epserde = "0.13" +rayon = "1" +anyhow = "1" +clap = { version = "4", features = ["derive"] } +tracing = "0.1.44" +tracing-subscriber = { version = "0.3", features = ["fmt", "env-filter"] } + +# The generation the indexes to convert were built with, under other names +# so that both can live in this one binary. +ptr_hash_old = { package = "ptr_hash", version = "=1.1.0" } +epserde_old = { package = "epserde", version = "=0.8.0" } +cacheline_ef_old = { package = "cacheline-ef", version = "=1.1.0" } + +[profile.release] +debug = 1 diff --git a/tools/migrate-mphf/src/commit.rs b/tools/migrate-mphf/src/commit.rs new file mode 100644 index 00000000..b130e308 --- /dev/null +++ b/tools/migrate-mphf/src/commit.rs @@ -0,0 +1,98 @@ +//! Crash-safe replacement of a layer's files by their converted versions. +//! +//! Everything new is written under `/.migrate_mphf/` first; nothing of +//! the layer is touched until that is complete and verified. Then a `COMMIT` +//! marker is written, and [`finish`] moves the staged files into place. Every +//! step of [`finish`] is idempotent ("if the staged item still exists, move +//! it"), so a layer interrupted after `COMMIT` is simply finished by the next +//! run. Files are only ever replaced by `rename`, never written in place: +//! some of them are hard-linked from elsewhere (`ls -l` link count 2), and an +//! in-place write would corrupt the other link. + +use std::fs; +use std::io; +use std::path::Path; + +use anyhow::{Context, Result}; + +pub const STAGING: &str = ".migrate_mphf"; +pub const COMMIT: &str = "COMMIT"; +/// Written last: the layer is converted, skip it on later runs. +pub const DONE: &str = ".mphf_migrated"; +/// Where derived annexes go instead of being deleted. +pub const STALE_DIR: &str = "stale_annexes_pre_ptrhash2"; + +/// Replaced as directories. +const DIRS: [&str; 2] = ["presence", "counts"]; +/// Replaced as files; `mphf.bin` last. +const FILES: [&str; 3] = ["evidence.bin", "fingerprint.bin", "mphf.bin"]; + +/// Slot-ordered or slot-derived annexes of a layer: wrong (silently) once the +/// slot numbering changes, so they are set aside, to be rebuilt. +const LAYER_ANNEXES: [&str; 7] = [ + "siblings.psib", + "entropy.pent", + "entropy.noamb.pent", + "pairweight.ppwt", + "pairweight.noamb.ppwt", + "quartet.pbiv", + "quartet.noamb.pbiv", +]; + +/// Index-level annexes derived from the sibling annex. +pub const INDEX_ANNEXES: [&str; 2] = ["family_overlap.povl", "family_overlap.noamb.povl"]; + +/// Move the staged files into `dir`, set the stale annexes aside, mark the +/// layer done and drop the staging area. +pub fn finish(dir: &Path) -> Result<()> { + let staging = dir.join(STAGING); + + for name in DIRS { + let staged = staging.join(name); + if staged.exists() { + let target = dir.join(name); + if target.exists() { + fs::remove_dir_all(&target).with_context(|| format!("removing {}", target.display()))?; + } + fs::rename(&staged, &target).with_context(|| format!("installing {}", target.display()))?; + } + } + for name in FILES { + let staged = staging.join(name); + if staged.exists() { + let target = dir.join(name); + fs::rename(&staged, &target).with_context(|| format!("installing {}", target.display()))?; + } + } + + set_aside(dir, &LAYER_ANNEXES)?; + + fs::write(dir.join(DONE), env!("CARGO_PKG_VERSION"))?; + fs::remove_dir_all(&staging)?; + Ok(()) +} + +/// Move each of `names` that exists in `dir` into `dir/STALE_DIR/`. +/// Returns how many were moved. +pub fn set_aside(dir: &Path, names: &[&str]) -> Result { + let aside = dir.join(STALE_DIR); + let mut moved = 0; + for name in names { + let from = dir.join(name); + if !from.exists() { + continue; + } + fs::create_dir_all(&aside)?; + fs::rename(&from, aside.join(name)).with_context(|| format!("setting aside {}", from.display()))?; + moved += 1; + } + Ok(moved) +} + +/// Remove a staging area left by an interrupted, uncommitted run. +pub fn discard(dir: &Path) -> io::Result<()> { + match fs::remove_dir_all(dir.join(STAGING)) { + Err(e) if e.kind() != io::ErrorKind::NotFound => Err(e), + _ => Ok(()), + } +} diff --git a/tools/migrate-mphf/src/data.rs b/tools/migrate-mphf/src/data.rs new file mode 100644 index 00000000..1e840a5e --- /dev/null +++ b/tools/migrate-mphf/src/data.rs @@ -0,0 +1,100 @@ +//! Permute the per-slot files of a layer into `staging/`. +//! +//! Presence and count matrices always come out in the compact row-major +//! (sparse) format, whatever they were: a dense source is first converted +//! sequentially (`build_from_dense`), then permuted from the sparse form, +//! whose rows are cheap to read at arbitrary slots. + +use std::fs; +use std::path::Path; + +use anyhow::{Result, ensure}; +use obicompactvec::{ + PersistentBitMatrix, PersistentIntMatrix, PersistentSparseBitMatrixBuilder, + PersistentSparseCompactIntMatrixBuilder, +}; +use obikindex::layer::evidence::{Evidence, EvidenceWriter}; +use obikindex::layer::fingerprint::{FingerprintVec, FingerprintVecWriter}; + +use crate::plan::Plan; +use crate::util::oki; + +/// Every per-slot file of the layer in `dir` that exists, permuted into `staging`. +pub fn permute_all(dir: &Path, staging: &Path, plan: &Plan) -> Result<()> { + if dir.join("evidence.bin").exists() { + evidence(dir, staging, plan)?; + } + if dir.join("fingerprint.bin").exists() { + fingerprint(dir, staging, plan)?; + } + if dir.join("presence").is_dir() { + presence(dir, staging, plan)?; + } + if dir.join("counts").is_dir() { + counts(dir, staging, plan)?; + } + Ok(()) +} + +fn evidence(dir: &Path, staging: &Path, plan: &Plan) -> Result<()> { + let old = oki(Evidence::open(&dir.join("evidence.bin")))?; + ensure!(old.len() == plan.n, "evidence.bin has {} slots, layer has {}", old.len(), plan.n); + let mut out = EvidenceWriter::new(plan.n); + for (s, &o) in plan.new_to_old.iter().enumerate() { + let (chunk_id, rank) = old.decode(o as usize); + out.set(s, chunk_id, rank); + } + oki(out.write(&staging.join("evidence.bin"))) +} + +fn fingerprint(dir: &Path, staging: &Path, plan: &Plan) -> Result<()> { + let old = oki(FingerprintVec::open(&dir.join("fingerprint.bin")))?; + ensure!(old.n() == plan.n, "fingerprint.bin has {} slots, layer has {}", old.n(), plan.n); + let mut out = FingerprintVecWriter::new(plan.n, old.b()); + for (s, &o) in plan.new_to_old.iter().enumerate() { + out.set(s, old.get(o as usize)); + } + oki(out.write(&staging.join("fingerprint.bin"))) +} + +fn presence(dir: &Path, staging: &Path, plan: &Plan) -> Result<()> { + let out = staging.join("presence"); + let src = match PersistentBitMatrix::open(dir)? { + // Mono-genome: no file, nothing is attached to slots. + PersistentBitMatrix::Implicit { .. } => return Ok(()), + PersistentBitMatrix::Sparse(s) => { + ensure!(s.n() == plan.n, "presence has {} rows, layer has {}", s.n(), plan.n); + PersistentSparseBitMatrixBuilder::build_permuted(&s, &plan.new_to_old, &out)?.close()?; + return Ok(()); + } + dense => dense, + }; + ensure!(src.n() == plan.n, "presence has {} rows, layer has {}", src.n(), plan.n); + let tmp = staging.join("presence_dense_to_sparse"); + let sparse = PersistentSparseBitMatrixBuilder::build_from_dense(&src, &tmp)?.finish()?; + drop(src); + PersistentSparseBitMatrixBuilder::build_permuted(&sparse, &plan.new_to_old, &out)?.close()?; + drop(sparse); + fs::remove_dir_all(&tmp)?; + Ok(()) +} + +fn counts(dir: &Path, staging: &Path, plan: &Plan) -> Result<()> { + let out = staging.join("counts"); + let src = match PersistentIntMatrix::open(dir)? { + PersistentIntMatrix::Sparse(s) => { + ensure!(s.n() == plan.n, "counts has {} rows, layer has {}", s.n(), plan.n); + PersistentSparseCompactIntMatrixBuilder::build_permuted(&s, &plan.new_to_old, &out)?.close()?; + return Ok(()); + } + dense => dense, + }; + ensure!(src.n() == plan.n, "counts has {} rows, layer has {}", src.n(), plan.n); + let tmp = staging.join("counts_dense_to_sparse"); + let sparse = PersistentSparseCompactIntMatrixBuilder::build_from_dense(&src, &tmp)?.finish()?; + drop(src); + PersistentSparseCompactIntMatrixBuilder::build_permuted(&sparse, &plan.new_to_old, &out)?.close()?; + drop(sparse); + fs::remove_dir_all(&tmp)?; + Ok(()) +} diff --git a/tools/migrate-mphf/src/layer.rs b/tools/migrate-mphf/src/layer.rs new file mode 100644 index 00000000..e9f98f5d --- /dev/null +++ b/tools/migrate-mphf/src/layer.rs @@ -0,0 +1,75 @@ +//! Convert one layer directory: new MPHF, permuted per-slot data, verified, +//! then installed atomically (see `commit`). + +use std::fs; +use std::path::Path; + +use anyhow::{Result, anyhow, ensure}; +use epserde::prelude::*; +use obikindex::layer::{Mphf, mphf_params}; +use obiskio::UnitigFileReader; + +use crate::util::sk; +use crate::{commit, data, old, plan, verify}; + +pub struct Options { + /// How many k-mers per layer to compare old against new (ignored with `verify_full`). + pub verify_sample: usize, + pub verify_full: bool, + /// Do everything except installing the result. + pub dry_run: bool, +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum Outcome { + /// Already converted by an earlier run. + Skipped, + /// Interrupted after verification by an earlier run; installed now. + Resumed, + Converted { n: usize, verified: usize }, + /// Everything but the installation. + Checked { n: usize, verified: usize }, +} + +pub fn convert(dir: &Path, opts: &Options) -> Result { + if dir.join(commit::DONE).exists() { + commit::discard(dir)?; + return Ok(Outcome::Skipped); + } + let staging = dir.join(commit::STAGING); + if staging.join(commit::COMMIT).exists() { + commit::finish(dir)?; + return Ok(Outcome::Resumed); + } + commit::discard(dir)?; + fs::create_dir_all(&staging)?; + + let n = sk(UnitigFileReader::open_sequential(&dir.join("unitigs.bin")))?.n_kmers(); + ensure!(n <= u32::MAX as usize, "layer has {n} k-mers, more than the 2^32 this tool handles"); + + let verified = if n == 0 { + empty_mphf(&staging)?; + 0 + } else { + let old_mphf = old::load(&dir.join("mphf.bin"))?; + let plan = plan::build(dir, &staging, n, &old_mphf)?; + data::permute_all(dir, &staging, &plan)?; + let stride = if opts.verify_full { 1 } else { (n / opts.verify_sample.max(1)).max(1) }; + verify::check(dir, &staging, &plan, &old_mphf, stride)? + }; + + if opts.dry_run { + commit::discard(dir)?; + return Ok(Outcome::Checked { n, verified }); + } + fs::write(staging.join(commit::COMMIT), b"")?; + commit::finish(dir)?; + Ok(Outcome::Converted { n, verified }) +} + +/// An empty layer still carries an MPHF (of nothing), like `MphfLayer::build` writes. +fn empty_mphf(staging: &Path) -> Result<()> { + let mphf = Mphf::try_new(&[] as &[u64], mphf_params()) + .ok_or_else(|| anyhow!("empty MPHF construction failed"))?; + unsafe { mphf.store(staging.join("mphf.bin")) }.map_err(|e| anyhow!("storing the empty MPHF: {e}")) +} diff --git a/tools/migrate-mphf/src/main.rs b/tools/migrate-mphf/src/main.rs new file mode 100644 index 00000000..4de59ec2 --- /dev/null +++ b/tools/migrate-mphf/src/main.rs @@ -0,0 +1,121 @@ +//! One-shot converter for obikmer indexes whose layer MPHFs were built with +//! `ptr_hash` 1.x: rebuilds each MPHF with `ptr_hash` 2.x and carries the +//! per-slot data (evidence, fingerprint, presence/count matrices) over to the +//! new slot numbering, in place, layer by layer, verified before installing. +//! +//! Presence and count matrices come out in the compact row-major format. +//! Annexes derived from slot numbering (sibling, entropy, pair-weight, +//! quartet, family-overlap) are set aside under `stale_annexes_pre_ptrhash2/` +//! and must be rebuilt. + +mod commit; +mod data; +mod layer; +mod old; +mod plan; +mod util; +mod verify; + +use std::path::PathBuf; +use std::sync::atomic::{AtomicUsize, Ordering}; + +use anyhow::{Result, ensure}; +use clap::Parser; +use obikindex::KmerIndex; +use obisys::PartitionRunner; +use tracing::{info, warn}; + +use layer::{Options, Outcome}; +use util::oki; + +#[derive(Parser)] +#[command(about = "Convert an obikmer index from ptr_hash 1.x to ptr_hash 2.x MPHFs, in place")] +struct Cli { + /// Index directory (the one holding `index.meta` and `part_*`). + index: PathBuf, + + /// Limit the number of CPUs used. + #[arg(long)] + cpu_max: Option, + + /// K-mers compared old-vs-new per layer before installing it. + #[arg(long, default_value_t = 200_000)] + verify_sample: usize, + + /// Compare every k-mer of every layer (slow). + #[arg(long)] + verify_full: bool, + + /// Do everything except installing: convert into staging, verify, discard. + #[arg(long)] + dry_run: bool, + + /// Only these partitions (repeatable). The index-level annexes are then left alone. + #[arg(long)] + partition: Vec, + + /// Only these layers of each partition (repeatable). The index-level annexes are then left alone. + #[arg(long)] + layer: Vec, +} + +fn main() -> Result<()> { + tracing_subscriber::fmt() + .with_env_filter(tracing_subscriber::EnvFilter::try_from_default_env().unwrap_or_else(|_| "info".into())) + .init(); + let cli = Cli::parse(); + if let Some(n) = cli.cpu_max { + obisys::set_cpu_cap(n); + } + + // Holds the index's directory lock for the whole run, and sets k. + let index = oki(KmerIndex::open_lock(&cli.index))?; + let n_partitions = index.n_partitions(); + let partial = !cli.partition.is_empty() || !cli.layer.is_empty(); + let order: Vec = if cli.partition.is_empty() { (0..n_partitions).collect() } else { cli.partition.clone() }; + ensure!(order.iter().all(|&p| p < n_partitions), "index has only {n_partitions} partitions"); + + let opts = Options { verify_sample: cli.verify_sample, verify_full: cli.verify_full, dry_run: cli.dry_run }; + let converted = AtomicUsize::new(0); + let skipped = AtomicUsize::new(0); + + let mut done = 0usize; + PartitionRunner::new().run( + &order, + |p| -> Result> { + let n_layers = oki(index.n_layers(p))?; + let mut outcomes = Vec::new(); + for l in (0..n_layers).filter(|l| cli.layer.is_empty() || cli.layer.contains(l)) { + let dir = index.layer_path(p, l); + let outcome = layer::convert(&dir, &opts) + .map_err(|e| e.context(format!("partition {p}, layer {l} ({})", dir.display())))?; + match outcome { + Outcome::Skipped => skipped.fetch_add(1, Ordering::Relaxed), + _ => converted.fetch_add(1, Ordering::Relaxed), + }; + outcomes.push((l, outcome)); + } + Ok(outcomes) + }, + |p, outcomes, elapsed| { + done += 1; + info!("partition {p} ({done}/{}) in {:.1?}: {outcomes:?}", order.len(), elapsed); + }, + )?; + + if !cli.dry_run && !partial { + let moved = commit::set_aside(index.dir(), &commit::INDEX_ANNEXES)?; + if moved > 0 { + info!("{moved} index-level annex(es) set aside under {}", commit::STALE_DIR); + } + } else if !cli.dry_run { + warn!("partial run: index-level annexes (family overlap) not set aside; do it on the final pass"); + } + info!( + "done: {} layer(s) {}, {} already converted", + converted.load(Ordering::Relaxed), + if cli.dry_run { "checked" } else { "converted" }, + skipped.load(Ordering::Relaxed) + ); + Ok(()) +} diff --git a/tools/migrate-mphf/src/old.rs b/tools/migrate-mphf/src/old.rs new file mode 100644 index 00000000..f94fd913 --- /dev/null +++ b/tools/migrate-mphf/src/old.rs @@ -0,0 +1,17 @@ +//! The previous MPHF generation (`ptr_hash` 1.x), kept only to read the +//! `mphf.bin` files of indexes built before the migration. + +use std::path::Path; + +use anyhow::{Result, anyhow}; +use cacheline_ef_old::{CachelineEf, CachelineEfVec}; +use epserde_old::prelude::*; +use ptr_hash_old::{PtrHash, bucket_fn::CubicEps, hash::Xx64}; + +/// Exactly the type `obikindex` used before the migration. +pub type OldMphf = PtrHash>, Xx64, Vec>; + +pub fn load(path: &Path) -> Result { + OldMphf::load_full(path) + .map_err(|e| anyhow!("{}: not a ptr_hash 1.x MPHF (already converted?): {e}", path.display())) +} diff --git a/tools/migrate-mphf/src/plan.rs b/tools/migrate-mphf/src/plan.rs new file mode 100644 index 00000000..82ed1d2f --- /dev/null +++ b/tools/migrate-mphf/src/plan.rs @@ -0,0 +1,53 @@ +//! The slot permutation between a layer's old and new MPHF. +//! +//! A layer's MPHF gives each k-mer a slot, and every other per-slot file of +//! the layer (evidence, fingerprint, presence/count matrices) is indexed by +//! it. A new MPHF numbers the same k-mers differently, so the data has to +//! follow: the k-mers themselves come from `unitigs.bin`, which does not +//! depend on the MPHF at all. + +use std::path::Path; + +use anyhow::{Result, anyhow, ensure}; +use epserde::prelude::*; +use obikindex::layer::{Mphf, mphf_params}; +use obiskio::CanonicalKmerIter; +use rayon::prelude::*; + +use crate::old::OldMphf; +use crate::util::sk; + +/// `new_to_old[s]` is the old slot of the k-mer that the new MPHF puts in +/// slot `s`. Always a bijection on `0..n` (checked while it is built). +pub struct Plan { + pub n: usize, + pub new_to_old: Vec, +} + +/// Build the new MPHF of the layer whose `unitigs.bin` is in `dir`, store it +/// as `staging/mphf.bin`, and derive the permutation against `old`. +pub fn build(dir: &Path, staging: &Path, n: usize, old: &OldMphf) -> Result { + let unitigs = dir.join("unitigs.bin"); + + // Same construction as `MphfLayer::build`: a clonable mmap iterator, bridged. + let keys = sk(CanonicalKmerIter::new(&unitigs))?; + let new: Mphf = Mphf::new_from_par_iter(n, keys.map(|k| k.raw()).par_bridge(), mphf_params()); + unsafe { new.store(staging.join("mphf.bin")) }.map_err(|e| anyhow!("storing the new MPHF: {e}"))?; + + let mut new_to_old = vec![u32::MAX; n]; + let mut old_seen = vec![0u8; n.div_ceil(8)]; + for kmer in sk(CanonicalKmerIter::new(&unitigs))? { + let key = kmer.raw(); + let o = old.index(&key); + let s = new.index(&key); + ensure!(o < n, "old MPHF: slot {o} out of range (n = {n}) — is this layer's mphf.bin really the one of its unitigs.bin?"); + ensure!(s < n, "new MPHF: slot {s} out of range (n = {n})"); + ensure!(new_to_old[s] == u32::MAX, "new MPHF puts two k-mers in slot {s}"); + let (byte, bit) = (o / 8, 1u8 << (o % 8)); + ensure!(old_seen[byte] & bit == 0, "old MPHF puts two k-mers in slot {o}"); + old_seen[byte] |= bit; + new_to_old[s] = o as u32; + } + // n distinct new slots, all in range, among n: the map is total. + Ok(Plan { n, new_to_old }) +} diff --git a/tools/migrate-mphf/src/util.rs b/tools/migrate-mphf/src/util.rs new file mode 100644 index 00000000..9623bdf7 --- /dev/null +++ b/tools/migrate-mphf/src/util.rs @@ -0,0 +1,11 @@ +//! Error adapters: the libraries each have their own error type. + +use anyhow::{Result, anyhow}; + +pub fn sk(r: obiskio::SKResult) -> Result { + r.map_err(|e| anyhow!("{e}")) +} + +pub fn oki(r: obikindex::OKIResult) -> Result { + r.map_err(|e| anyhow!("{e}")) +} diff --git a/tools/migrate-mphf/src/verify.rs b/tools/migrate-mphf/src/verify.rs new file mode 100644 index 00000000..caacd09f --- /dev/null +++ b/tools/migrate-mphf/src/verify.rs @@ -0,0 +1,90 @@ +//! Check the staged files against the layer as it still is, before anything +//! is replaced. +//! +//! For a sample of k-mers read from `unitigs.bin`, the old chain (old MPHF → +//! old slot → old data) must agree with the new one (staged MPHF, loaded the +//! way queries load it → new slot → staged data): same evidence, same +//! fingerprint, same presence set, same counts. A full check is the same loop +//! with every k-mer. + +use std::path::Path; + +use anyhow::{Result, anyhow, ensure}; +use epserde::prelude::*; +use obicompactvec::{PersistentBitMatrix, PersistentIntMatrix, PersistentSparseBitMatrix, PersistentSparseCompactIntMatrix}; +use obikindex::layer::Mphf; +use obikindex::layer::evidence::Evidence; +use obikindex::layer::fingerprint::FingerprintVec; +use obiskio::CanonicalKmerIter; + +use crate::old::OldMphf; +use crate::plan::Plan; +use crate::util::{oki, sk}; + +/// Both sides of one per-slot file, when the layer has it. +struct Pair { + old: O, + new: N, +} + +fn pair( + exists: bool, + old: impl FnOnce() -> Result, + new: impl FnOnce() -> Result, +) -> Result>> { + Ok(if exists { Some(Pair { old: old()?, new: new()? }) } else { None }) +} + +/// Returns how many k-mers were compared. +pub fn check(dir: &Path, staging: &Path, plan: &Plan, old_mphf: &OldMphf, stride: usize) -> Result { + let staged_mphf = unsafe { Mphf::mmap(staging.join("mphf.bin"), Flags::empty()) } + .map_err(|e| anyhow!("staged mphf.bin does not load: {e}"))?; + let new_mphf = staged_mphf.uncase(); + + let evidence = pair( + staging.join("evidence.bin").exists(), + || oki(Evidence::open(&dir.join("evidence.bin"))), + || oki(Evidence::open(&staging.join("evidence.bin"))), + )?; + let fingerprint = pair( + staging.join("fingerprint.bin").exists(), + || oki(FingerprintVec::open(&dir.join("fingerprint.bin"))), + || oki(FingerprintVec::open(&staging.join("fingerprint.bin"))), + )?; + let presence = pair( + staging.join("presence").is_dir(), + || Ok(PersistentBitMatrix::open(dir)?), + || Ok(PersistentSparseBitMatrix::open(&staging.join("presence"))?), + )?; + let counts = pair( + staging.join("counts").is_dir(), + || Ok(PersistentIntMatrix::open(dir)?), + || Ok(PersistentSparseCompactIntMatrix::open(&staging.join("counts"))?), + )?; + + let mut compared = 0; + for (i, kmer) in sk(CanonicalKmerIter::new(&dir.join("unitigs.bin")))?.enumerate() { + if i % stride != 0 { + continue; + } + let key = kmer.raw(); + let o = old_mphf.index(&key); + let s = new_mphf.index(&key); + ensure!(s < plan.n && plan.new_to_old[s] as usize == o, "k-mer #{i}: staged MPHF slot {s} disagrees with the plan (old slot {o})"); + + if let Some(p) = &evidence { + ensure!(p.old.decode(o) == p.new.decode(s), "k-mer #{i}: evidence differs (old slot {o}, new slot {s})"); + } + if let Some(p) = &fingerprint { + ensure!(p.old.get(o) == p.new.get(s), "k-mer #{i}: fingerprint differs (old slot {o}, new slot {s})"); + } + if let Some(p) = &presence { + ensure!(p.old.row(o) == p.new.row(s), "k-mer #{i}: presence row differs (old slot {o}, new slot {s})"); + } + if let Some(p) = &counts { + ensure!(p.old.row(o) == p.new.row(s), "k-mer #{i}: count row differs (old slot {o}, new slot {s})"); + } + compared += 1; + } + Ok(compared) +}