Skip to content

web search done right

better cache locality for fast field reader. instead of going from field -> doc -> value, we can go from doc -> field -> value and thereby reuse the doc -> field part for all fields in the document.

Mikkel Denkereb7e96bf5070
diff --git a/crates/core/src/collector.rs b/crates/core/src/collector.rs
index c32375bf..1483aae0 100644
--- a/crates/core/src/collector.rs
+++ b/crates/core/src/collector.rs
@@ -141,19 +141,11 @@ pub struct TopSegmentCollector {
impl TopSegmentCollector {
fn get_hash(&self, doc: &DocId, field1: &FastField, field2: &FastField) -> Prehashed {
- let hash: Option<u64> = self
- .fastfield_segment_reader
- .get_field_reader(field1)
- .get(doc)
- .into();
- let hash1 = hash.unwrap();
+ let field_reader = self.fastfield_segment_reader.get_field_reader(doc);
- let hash: Option<u64> = self
- .fastfield_segment_reader
- .get_field_reader(field2)
- .get(doc)
- .into();
- let hash2 = hash.unwrap();
+ let hash1 = field_reader.get(field1).into();
+
+ let hash2 = field_reader.get(field2).into();
let hash = [hash1, hash2];
combine_u64s(hash).into()
@@ -178,8 +170,8 @@ impl TopSegmentCollector {
let simhash: Option<u64> = self
.fastfield_segment_reader
- .get_field_reader(&FastField::SimHash)
- .get(&doc)
+ .get_field_reader(&doc)
+ .get(&FastField::SimHash)
.into();
self.bucket_collector.insert(SegmentDoc {
diff --git a/crates/core/src/fastfield_reader.rs b/crates/core/src/fastfield_reader.rs
index bbb94d5a..cfea8969 100644
--- a/crates/core/src/fastfield_reader.rs
+++ b/crates/core/src/fastfield_reader.rs
@@ -48,26 +48,39 @@ impl FastFieldReader {
let mut field_readers = Vec::new();
+ let mut tv_readers = EnumMap::new();
+
for field in Field::all().filter_map(|field| field.as_fast()) {
- let field_reader = match field.data_type() {
+ match field.data_type() {
DataType::U64 => {
let reader = fastfield_readers.u64(field.name()).unwrap();
- FieldReader {
- data: Arc::new(reader.values.iter().collect()),
- }
+ tv_readers.insert(field, reader);
}
};
-
- field_readers.push((field, field_reader));
}
- field_readers.sort_by_key(|(field, _)| *field as usize);
+ for doc in 0..reader.max_doc() as usize {
+ let mut field_reader = FieldReader {
+ data: EnumMap::new(),
+ };
+
+ for field in Field::all().filter_map(|field| field.as_fast()) {
+ match field.data_type() {
+ DataType::U64 => {
+ let reader = tv_readers.get(field).unwrap();
+ field_reader
+ .data
+ .insert(field, reader.values.get_val(doc as u32))
+ }
+ };
+ }
+
+ field_readers.push(field_reader);
+ }
segments.insert(
reader.segment_id(),
- Arc::new(SegmentReader {
- field_readers: field_readers.into_iter().collect(),
- }),
+ Arc::new(SegmentReader { field_readers }),
);
}
@@ -77,23 +90,22 @@ impl FastFieldReader {
}
}
-#[derive(Clone)]
pub struct FieldReader {
- data: Arc<Vec<u64>>,
+ data: EnumMap<FastField, u64>,
}
impl FieldReader {
- pub fn get(&self, doc: &DocId) -> u64 {
- self.data[*doc as usize]
+ pub fn get(&self, field: &FastField) -> u64 {
+ self.data.get(*field).copied().unwrap()
}
}
pub struct SegmentReader {
- field_readers: EnumMap<FastField, FieldReader>,
+ field_readers: Vec<FieldReader>,
}
impl SegmentReader {
- pub fn get_field_reader(&self, field: &FastField) -> &FieldReader {
- self.field_readers.get(*field).unwrap()
+ pub fn get_field_reader(&self, doc: &DocId) -> &FieldReader {
+ &self.field_readers.as_slice()[*doc as usize]
}
}
diff --git a/crates/core/src/query/pattern_query/scorer.rs b/crates/core/src/query/pattern_query/scorer.rs
index 80e4c2aa..f11b76fd 100644
--- a/crates/core/src/query/pattern_query/scorer.rs
+++ b/crates/core/src/query/pattern_query/scorer.rs
@@ -146,8 +146,8 @@ impl EmptyFieldScorer {
fn num_tokes(&self, doc: DocId) -> u64 {
let s: Option<u64> = self
.segment_reader
- .get_field_reader(&self.num_tokens_fastfield)
- .get(&doc)
+ .get_field_reader(&doc)
+ .get(&self.num_tokens_fastfield)
.into();
s.unwrap_or_default()
}
@@ -312,8 +312,8 @@ impl NormalPatternScorer {
let mut slop = 1;
let num_tokens_doc: Option<u64> = self
.segment_reader
- .get_field_reader(&self.num_tokens_field)
- .get(&self.doc())
+ .get_field_reader(&self.doc())
+ .get(&self.num_tokens_field)
.into();
let num_tokens_doc = num_tokens_doc.unwrap();
diff --git a/crates/core/src/ranking/signal.rs b/crates/core/src/ranking/signal.rs
index 6dc5ddfe..afdab7a4 100644
--- a/crates/core/src/ranking/signal.rs
+++ b/crates/core/src/ranking/signal.rs
@@ -311,131 +311,78 @@ impl Signal {
}
}
- fn host_id(&self, aggregator: &SignalAggregator, doc: DocId) -> Option<NodeID> {
- aggregator.segment_reader.as_ref().and_then(|reader| {
- let node_id: Option<u64> = reader
- .borrow_mut()
- .fastfield_reader
- .get_field_reader(&FastField::HostNodeID)
- .get(&doc)
- .into();
- let node_id = node_id.unwrap();
-
- if node_id == u64::MAX {
- None
- } else {
- Some(node_id.into())
- }
- })
- }
-
- fn fastfield_value(&self, aggregator: &SignalAggregator, doc: &DocId) -> Option<u64> {
- aggregator.segment_reader.as_ref().and_then(|reader| {
- self.as_fastfield().as_ref().map(|fast_field| {
- reader
- .borrow()
- .fastfield_reader
- .get_field_reader(fast_field)
- .get(doc)
- })
- })
- }
-
fn compute(self, signal_aggregator: &SignalAggregator, doc: DocId) -> Option<ComputedSignal> {
let coefficient = signal_aggregator.coefficient(&self);
if coefficient == 0.0 {
return None;
}
+ let mut seg_reader = signal_aggregator
+ .segment_reader
+ .as_ref()
+ .unwrap()
+ .borrow_mut();
+ let fastfield_reader = seg_reader.fastfield_reader.get_field_reader(&doc);
+
+ let node_id = fastfield_reader.get(&FastField::HostNodeID);
+ let host_id: Option<NodeID> = if node_id == u64::MAX {
+ None
+ } else {
+ Some(node_id.into())
+ };
+
let value: Option<f64> = match self {
Signal::HostCentrality | Signal::PageCentrality => {
- let field_value: Option<u64> = self
- .fastfield_value(signal_aggregator, &doc)
- .and_then(|val| val.into());
-
- field_value.map(|val| val as f64 / FLOAT_SCALING as f64)
+ let val = fastfield_reader.get(&self.as_fastfield().unwrap());
+ Some(val as f64 / FLOAT_SCALING as f64)
}
Signal::HostCentralityRank | Signal::PageCentralityRank => {
- let field_value: Option<u64> = self
- .fastfield_value(signal_aggregator, &doc)
- .and_then(|val| val.into());
-
- field_value.map(|val| val as f64).map(score_rank)
+ let val = fastfield_reader.get(&self.as_fastfield().unwrap());
+ Some(score_rank(val as f64))
}
Signal::IsHomepage => {
- let field_value: Option<u64> = self
- .fastfield_value(signal_aggregator, &doc)
- .and_then(|val| val.into());
-
- field_value.map(|val| val as f64)
+ let val = fastfield_reader.get(&self.as_fastfield().unwrap());
+ Some(val as f64)
}
Signal::LinkDensity => {
- let field_value: Option<u64> = self
- .fastfield_value(signal_aggregator, &doc)
- .and_then(|val| val.into());
-
- field_value
- .map(|val| val as f64 / FLOAT_SCALING as f64)
- .map(score_link_density)
+ let val = fastfield_reader.get(&self.as_fastfield().unwrap());
+ Some(score_link_density(val as f64 / FLOAT_SCALING as f64))
}
Signal::FetchTimeMs => {
- let field_value: Option<u64> = self
- .fastfield_value(signal_aggregator, &doc)
- .and_then(|val| val.into());
+ let fetch_time_ms = fastfield_reader.get(&self.as_fastfield().unwrap()) as usize;
- field_value.map(|v| v as usize).map(|fetch_time_ms| {
- if fetch_time_ms >= signal_aggregator.fetch_time_ms_cache.len() {
- 0.0
- } else {
- signal_aggregator.fetch_time_ms_cache[fetch_time_ms]
- }
- })
+ if fetch_time_ms >= signal_aggregator.fetch_time_ms_cache.len() {
+ Some(0.0)
+ } else {
+ Some(signal_aggregator.fetch_time_ms_cache[fetch_time_ms])
+ }
}
Signal::UpdateTimestamp => {
- let field_value: Option<u64> = self
- .fastfield_value(signal_aggregator, &doc)
- .and_then(|val| val.into());
+ let val = fastfield_reader.get(&self.as_fastfield().unwrap()) as usize;
- field_value
- .map(|v| v as usize)
- .map(|update_timestamp| score_timestamp(update_timestamp, signal_aggregator))
+ Some(score_timestamp(val, signal_aggregator))
}
Signal::TrackerScore => {
- let field_value: Option<u64> = self
- .fastfield_value(signal_aggregator, &doc)
- .and_then(|val| val.into());
-
- field_value.map(|num_trackers| score_trackers(num_trackers as f64))
+ let val = fastfield_reader.get(&self.as_fastfield().unwrap());
+ Some(score_trackers(val as f64))
}
Signal::UrlDigits => {
- let field_value: Option<u64> = self
- .fastfield_value(signal_aggregator, &doc)
- .and_then(|val| val.into());
-
- field_value.map(|num_digits| score_digits(num_digits as f64))
+ let val = fastfield_reader.get(&self.as_fastfield().unwrap());
+ Some(score_digits(val as f64))
}
Signal::UrlSlashes => {
- let field_value: Option<u64> = self
- .fastfield_value(signal_aggregator, &doc)
- .and_then(|val| val.into());
-
- field_value.map(|num_slashes| score_slashes(num_slashes as f64))
+ let val = fastfield_reader.get(&self.as_fastfield().unwrap());
+ Some(score_slashes(val as f64))
}
Signal::Region => {
- let field_value: Option<u64> = self
- .fastfield_value(signal_aggregator, &doc)
- .and_then(|val| val.into());
-
- field_value
- .map(Region::from_id)
- .map(|region| score_region(region, signal_aggregator))
+ let val = fastfield_reader.get(&self.as_fastfield().unwrap());
+ let region = Region::from_id(val);
+ Some(score_region(region, signal_aggregator))
}
Signal::QueryCentrality => {
- let host_id = self.host_id(signal_aggregator, doc);
host_id.and_then(|host_id| signal_aggregator.query_centrality(host_id))
}
Signal::InboundSimilarity => {
- let host_id = self.host_id(signal_aggregator, doc);
host_id.map(|host_id| signal_aggregator.inbound_similarity(host_id))
}
Signal::Bm25Title
@@ -457,14 +404,10 @@ impl Signal {
| Signal::Bm25DomainNameIfHomepageNoTokenizer
| Signal::Bm25DomainIfHomepageNoTokenizer
| Signal::Bm25TitleIfHomepage
- | Signal::Bm25BacklinkText => signal_aggregator.segment_reader.as_ref().map(|reader| {
- reader
- .borrow_mut()
- .text_fields
- .get_mut(self.as_textfield().unwrap())
- .map(|field| bm25(field, doc))
- .unwrap_or(0.0)
- }),
+ | Signal::Bm25BacklinkText => seg_reader
+ .text_fields
+ .get_mut(self.as_textfield().unwrap())
+ .map(|field| bm25(field, doc)),
Signal::CrossEncoderSnippet => None, // this is calculated in a later step
Signal::CrossEncoderTitle => None, // this is calculated in a later step