AI search engine and MCP server for bots and agents. One Rust binary indexes code, docs, logs, JSONL/CSV and PDFs for BM25 full-text, vector and hybrid search, code search without grep, agent memory and RAG. Elasticsearch-compatible API; Corpus Hub serves hundreds of reference memory corpora.
Rust agent-memoryai-agentsbm25claude-codeclicode-searchcursordatabaseelasticsearchfull-text-searchhybrid-searchjsonllocal-firstmcpmcp-servermodel-context-protocolragrustsearch-enginevector-search
perf(search): parallelise memtable terms/cardinality columnar fold across shards
xerj-org0fe5c0cfc16a
diff --git a/engine/crates/xerj-engine/src/memtable.rs b/engine/crates/xerj-engine/src/memtable.rsindex 44d7cd44f..6219beca9 100644--- a/engine/crates/xerj-engine/src/memtable.rs+++ b/engine/crates/xerj-engine/src/memtable.rs@@ -1000,40 +1000,81 @@ impl ShardedFtsMemtable {&self,field: &str,) -> Option<(std::collections::HashMap<String, u64>, u64)> {- let mut counts: std::collections::HashMap<String, u64> =- std::collections::HashMap::new();- let mut missing: u64 = 0;- for s in &self.shards {- let g = s.read();- let n = g.doc_count();- if n == 0 {- continue;- }- if g.doc_values.array_fields.contains(field)- || g.doc_values.numeric.contains_key("_doc_count")- || g.doc_values.keyword.contains_key("_doc_count")- {- return None;- }- match g.doc_values.keyword.get(field) {- None => {- // No doc in this shard carries the field as a scalar.- missing += n as u64;+ use rayon::prelude::*;+ // Per-shard columnar term-count folding, fanned out across the 16+ // shards on the rayon pool. This is a FULL O(memtable) keyword-column+ // walk on EVERY terms/cardinality agg request (unlike the incremental+ // sort-candidate cache); under a sustained 120 k-doc/s bulk writer the+ // live memtable sits at 100-270 k docs and the serial single-thread+ // walk was the dominant `fast_aggs` read-under-write p95/p99 term+ // (25-32 ms/query, profiled). Each shard folds into its OWN local map+ // under a short read lock, so (a) the CPU work spreads across cores and+ // (b) every shard's read-lock hold window shrinks ~16× — reducing the+ // reader/writer contention with the concurrent bulk ingest. The+ // per-shard maps are merged commutatively below, so the result is+ // byte-identical to the serial fold (HashMap merge is associative;+ // `missing` is a plain sum). Any shard that hits a bail condition+ // (array-valued field, `_doc_count` weights) yields `None`, and the+ // `collect::<Option<_>>` short-circuits the whole call to `None` —+ // exactly the legacy "return None on the first ineligible shard"+ // semantics (the caller then falls back to the brute per-doc walk).+ let per_shard: Option<Vec<(std::collections::HashMap<String, u64>, u64)>> = self+ .shards+ .par_iter()+ .map(|s| {+ let g = s.read();+ let n = g.doc_count();+ if n == 0 {+ return Some((std::collections::HashMap::new(), 0u64));+ }+ if g.doc_values.array_fields.contains(field)+ || g.doc_values.numeric.contains_key("_doc_count")+ || g.doc_values.keyword.contains_key("_doc_count")+ {+ return None;}- Some(col) => {- let mut present: u64 = 0;- for v in col.iter() {- if let Some(s) = v.as_deref() {- present += 1;- if let Some(c) = counts.get_mut(s) {- *c += 1;- } else {- counts.insert(s.to_string(), 1);+ let mut counts: std::collections::HashMap<String, u64> =+ std::collections::HashMap::new();+ let missing: u64 = match g.doc_values.keyword.get(field) {+ None => {+ // No doc in this shard carries the field as a scalar.+ n as u64+ }+ Some(col) => {+ let mut present: u64 = 0;+ for v in col.iter() {+ if let Some(s) = v.as_deref() {+ present += 1;+ if let Some(c) = counts.get_mut(s) {+ *c += 1;+ } else {+ counts.insert(s.to_string(), 1);+ }}}+ // Nones + docs past the column tail are missing.+ n as u64 - present}- // Nones + docs past the column tail are missing.- missing += n as u64 - present;+ };+ Some((counts, missing))+ })+ .collect();+ let per_shard = per_shard?;+ // Merge the per-shard partials (commutative — identical to the serial+ // single-map accumulation this replaces).+ let mut counts: std::collections::HashMap<String, u64> =+ std::collections::HashMap::new();+ let mut missing: u64 = 0;+ for (shard_counts, shard_missing) in per_shard {+ missing += shard_missing;+ if counts.is_empty() {+ // First non-empty partial becomes the base map — avoids+ // re-hashing its keys on the common single-populated-shard+ // path.+ counts = shard_counts;+ } else {+ for (term, cnt) in shard_counts {+ *counts.entry(term).or_insert(0) += cnt;}}}