use std::sync::atomic::{AtomicU64, Ordering};
use std::sync::Arc;
use std::time::Instant;
use parking_lot::RwLock;
use crate::error::Result;
use crate::index::SearchResult;
use crate::types::{ChunkId, TenantId};
use super::access_tracker::{AccessEvent, AccessTracker};
use super::hot_tier::HotTier;
use super::semantic_cache::{CachedResult, SemanticCache};
#[derive(Debug, Clone)]
pub struct TieredSearcherConfig {
pub enable_cache: bool,
pub enable_hot_tier: bool,
pub promotion_threshold: f32,
pub demotion_queries_threshold: u32,
pub auto_promote_on_project_match: bool,
pub debug_tier_decisions: bool,
}
impl Default for TieredSearcherConfig {
fn default() -> Self {
Self {
enable_cache: true,
enable_hot_tier: true,
promotion_threshold: 0.4,
demotion_queries_threshold: 100,
auto_promote_on_project_match: true,
debug_tier_decisions: false,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum SourceTier {
Cache,
Hot,
Warm,
}
#[derive(Debug, Clone)]
pub enum TierAction {
Promote {
from: SourceTier,
score: f32,
},
Demote {
reason: String,
},
None,
}
#[derive(Debug, Clone)]
pub struct TierDecision {
pub chunk_id: ChunkId,
pub action: TierAction,
pub reason: String,
pub score: Option<f32>,
pub source_tier: SourceTier,
}
#[derive(Debug, Clone)]
pub struct ScoredChunk {
pub chunk_id: ChunkId,
pub score: f32,
pub source_tier: SourceTier,
}
#[derive(Debug, Clone, Default)]
pub struct TieredTiming {
pub cache_lookup_ms: u64,
pub hot_tier_ms: u64,
pub warm_tier_ms: u64,
pub promotion_check_ms: u64,
pub total_ms: u64,
}
#[derive(Debug, Clone)]
pub struct TieredSearchResult {
pub results: Vec<ScoredChunk>,
pub source_tier: SourceTier,
pub cache_hit: bool,
pub hot_tier_hit: bool,
pub timing: TieredTiming,
pub tier_decisions: Vec<TierDecision>,
}
pub trait WarmTierSearch: Send + Sync {
fn search(&self, query_embedding: &[f32], k: usize) -> Result<Vec<SearchResult>>;
fn get_embedding(&self, chunk_id: &ChunkId) -> Option<Vec<f32>>;
fn get_version(&self) -> u64;
fn len(&self) -> usize;
fn is_empty(&self) -> bool {
self.len() == 0
}
}
pub struct TieredSearcher<W: WarmTierSearch> {
cache: Arc<SemanticCache>,
hot_tier: Arc<RwLock<HotTier>>,
access_tracker: Arc<RwLock<AccessTracker>>,
warm_tier: Arc<W>,
config: TieredSearcherConfig,
query_counter: AtomicU64,
last_demotion_check: AtomicU64,
}
impl<W: WarmTierSearch> TieredSearcher<W> {
pub fn new(
cache: Arc<SemanticCache>,
hot_tier: Arc<RwLock<HotTier>>,
access_tracker: Arc<RwLock<AccessTracker>>,
warm_tier: Arc<W>,
config: TieredSearcherConfig,
) -> Self {
Self {
cache,
hot_tier,
access_tracker,
warm_tier,
config,
query_counter: AtomicU64::new(0),
last_demotion_check: AtomicU64::new(current_time_ms() as u64),
}
}
pub fn warm_tier(&self) -> Arc<W> {
Arc::clone(&self.warm_tier)
}
pub fn config(&self) -> &TieredSearcherConfig {
&self.config
}
pub fn query_count(&self) -> u64 {
self.query_counter.load(Ordering::Relaxed)
}
pub fn search(
&self,
query_embedding: &[f32],
tenant_id: &TenantId,
project_id: Option<&str>,
k: usize,
) -> Result<TieredSearchResult> {
self.search_internal(query_embedding, tenant_id, project_id, k, false)
}
pub fn search_with_debug(
&self,
query_embedding: &[f32],
tenant_id: &TenantId,
project_id: Option<&str>,
k: usize,
) -> Result<TieredSearchResult> {
self.search_internal(query_embedding, tenant_id, project_id, k, true)
}
fn search_internal(
&self,
query_embedding: &[f32],
tenant_id: &TenantId,
project_id: Option<&str>,
k: usize,
debug: bool,
) -> Result<TieredSearchResult> {
let total_start = Instant::now();
let mut timing = TieredTiming::default();
let mut tier_decisions = Vec::new();
self.query_counter.fetch_add(1, Ordering::Relaxed);
let version = self.warm_tier.get_version();
let cache_start = Instant::now();
let cache_result = if self.config.enable_cache {
self.cache
.lookup_with_limit(query_embedding, tenant_id, project_id, version, k)
} else {
None
};
timing.cache_lookup_ms = cache_start.elapsed().as_millis() as u64;
if let Some(hit) = cache_result {
let results: Vec<ScoredChunk> = hit
.results
.into_iter()
.take(k)
.map(|r| ScoredChunk {
chunk_id: r.chunk_id,
score: r.score,
source_tier: SourceTier::Cache,
})
.collect();
timing.total_ms = total_start.elapsed().as_millis() as u64;
return Ok(TieredSearchResult {
results,
source_tier: SourceTier::Cache,
cache_hit: true,
hot_tier_hit: false,
timing,
tier_decisions,
});
}
let hot_start = Instant::now();
let hot_results = if self.config.enable_hot_tier {
let hot_tier = self.hot_tier.read();
hot_tier.search(query_embedding, k)?
} else {
Vec::new()
};
timing.hot_tier_ms = hot_start.elapsed().as_millis() as u64;
let hot_tier_hit = !hot_results.is_empty();
let warm_start = Instant::now();
let warm_results = self.warm_tier.search(query_embedding, k)?;
timing.warm_tier_ms = warm_start.elapsed().as_millis() as u64;
let merged = self.merge_results(&hot_results, &warm_results, k, debug, &mut tier_decisions);
{
let tracker = self.access_tracker.write();
for chunk in &merged {
let event = if let Some(proj) = project_id {
AccessEvent::with_project(chunk.chunk_id.clone(), proj.to_string())
} else {
AccessEvent::new(chunk.chunk_id.clone())
};
tracker.record_access(event);
}
}
if self.config.enable_cache && !merged.is_empty() {
let cached_results: Vec<CachedResult> = merged
.iter()
.map(|r| CachedResult {
chunk_id: r.chunk_id.clone(),
score: r.score,
text_preview: String::new(), })
.collect();
self.cache.insert_with_limit(
query_embedding.to_vec(),
tenant_id.clone(),
project_id.map(|s| s.to_string()),
cached_results,
version,
k,
);
}
let source_tier = if hot_tier_hit {
SourceTier::Hot
} else {
SourceTier::Warm
};
timing.total_ms = total_start.elapsed().as_millis() as u64;
Ok(TieredSearchResult {
results: merged,
source_tier,
cache_hit: false,
hot_tier_hit,
timing,
tier_decisions: if debug || self.config.debug_tier_decisions {
tier_decisions
} else {
Vec::new()
},
})
}
fn merge_results(
&self,
hot_results: &[SearchResult],
warm_results: &[SearchResult],
k: usize,
debug: bool,
tier_decisions: &mut Vec<TierDecision>,
) -> Vec<ScoredChunk> {
use std::collections::HashMap;
let mut seen: HashMap<ChunkId, ScoredChunk> = HashMap::new();
for result in hot_results {
if debug {
tier_decisions.push(TierDecision {
chunk_id: result.chunk_id.clone(),
action: TierAction::None,
reason: format!("Found in hot tier with score {:.3}", result.score),
score: Some(result.score),
source_tier: SourceTier::Hot,
});
}
seen.insert(
result.chunk_id.clone(),
ScoredChunk {
chunk_id: result.chunk_id.clone(),
score: result.score,
source_tier: SourceTier::Hot,
},
);
}
for result in warm_results {
if !seen.contains_key(&result.chunk_id) {
if debug {
tier_decisions.push(TierDecision {
chunk_id: result.chunk_id.clone(),
action: TierAction::None,
reason: format!("Found in warm tier with score {:.3}", result.score),
score: Some(result.score),
source_tier: SourceTier::Warm,
});
}
seen.insert(
result.chunk_id.clone(),
ScoredChunk {
chunk_id: result.chunk_id.clone(),
score: result.score,
source_tier: SourceTier::Warm,
},
);
}
}
let mut results: Vec<ScoredChunk> = seen.into_values().collect();
results.sort_by(|a, b| {
b.score
.partial_cmp(&a.score)
.unwrap_or(std::cmp::Ordering::Equal)
.then_with(|| a.chunk_id.cmp(&b.chunk_id))
});
results.truncate(k);
results
}
pub fn check_promotions(
&self,
tenant_id: &TenantId,
project_id: Option<&str>,
) -> Vec<TierDecision> {
if !self.config.enable_hot_tier {
return Vec::new();
}
let mut decisions = Vec::new();
let candidates = {
let tracker = self.access_tracker.read();
tracker.get_top_candidates(100, project_id)
};
let hot_tier = self.hot_tier.write();
for candidate in candidates {
if hot_tier.contains(&candidate.chunk_id) {
continue;
}
if candidate.score < self.config.promotion_threshold {
continue;
}
let embedding = match self.warm_tier.get_embedding(&candidate.chunk_id) {
Some(e) => e,
None => continue, };
match hot_tier.promote(
candidate.chunk_id.clone(),
embedding,
tenant_id.clone(),
candidate.score,
) {
Ok(true) => {
decisions.push(TierDecision {
chunk_id: candidate.chunk_id,
action: TierAction::Promote {
from: SourceTier::Warm,
score: candidate.score,
},
reason: format!(
"Promoted due to high access score ({:.3}): freq={:.2}, recency={:.2}, project={:.2}",
candidate.score,
candidate.frequency_component,
candidate.recency_component,
candidate.project_component,
),
score: Some(candidate.score),
source_tier: SourceTier::Warm,
});
}
Ok(false) => {
}
Err(_) => {
}
}
}
decisions
}
pub fn check_demotions(&self, project_id: Option<&str>) -> Vec<TierDecision> {
if !self.config.enable_hot_tier {
return Vec::new();
}
let query_count = self.query_counter.load(Ordering::Relaxed);
let threshold = self.config.demotion_queries_threshold as u64;
if query_count < threshold {
return Vec::new();
}
self.query_counter.store(0, Ordering::Relaxed);
self.last_demotion_check
.store(current_time_ms() as u64, Ordering::Relaxed);
let mut decisions = Vec::new();
let demotion_threshold = self.config.promotion_threshold * 0.5;
let all_candidates = {
let tracker = self.access_tracker.read();
tracker.get_top_candidates(1000, project_id)
};
let hot_tier = self.hot_tier.write();
for candidate in all_candidates {
if !hot_tier.contains(&candidate.chunk_id) {
continue;
}
if candidate.score < demotion_threshold {
if hot_tier.demote(&candidate.chunk_id) {
decisions.push(TierDecision {
chunk_id: candidate.chunk_id,
action: TierAction::Demote {
reason: format!(
"Score ({:.3}) dropped below demotion threshold ({:.3})",
candidate.score, demotion_threshold
),
},
reason: format!(
"Demoted due to low access score ({:.3} < {:.3})",
candidate.score, demotion_threshold
),
score: Some(candidate.score),
source_tier: SourceTier::Hot,
});
}
}
}
decisions
}
pub fn run_maintenance(&self, tenant_id: &TenantId) -> MaintenanceResult {
let start = Instant::now();
let promotions = self.check_promotions(tenant_id, None);
let demotions = self.check_demotions(None);
let evictions = {
let hot_tier = self.hot_tier.write();
let total_indexed = self.warm_tier.len();
hot_tier.evict_if_needed(total_indexed)
};
self.cache.prune_index();
MaintenanceResult {
promotions_count: promotions.len(),
demotions_count: demotions.len(),
evictions_count: evictions,
duration_ms: start.elapsed().as_millis() as u64,
promotion_decisions: promotions,
demotion_decisions: demotions,
}
}
pub fn maybe_promote_on_access(
&self,
chunk_id: &ChunkId,
tenant_id: &TenantId,
project_id: Option<&str>,
) -> Option<TierDecision> {
if !self.config.auto_promote_on_project_match || !self.config.enable_hot_tier {
return None;
}
let project_id = project_id?;
{
let hot_tier = self.hot_tier.read();
if hot_tier.contains(chunk_id) {
return None;
}
}
let score = {
let tracker = self.access_tracker.read();
tracker.get_promotion_score(chunk_id, Some(project_id))
};
if !score.eligible || score.score < self.config.promotion_threshold {
return None;
}
if score.project_component == 0.0 {
return None;
}
let embedding = self.warm_tier.get_embedding(chunk_id)?;
let hot_tier = self.hot_tier.write();
match hot_tier.promote(chunk_id.clone(), embedding, tenant_id.clone(), score.score) {
Ok(true) => Some(TierDecision {
chunk_id: chunk_id.clone(),
action: TierAction::Promote {
from: SourceTier::Warm,
score: score.score,
},
reason: format!(
"Auto-promoted due to project match and high score ({:.3})",
score.score
),
score: Some(score.score),
source_tier: SourceTier::Warm,
}),
_ => None,
}
}
}
#[derive(Debug, Clone)]
pub struct MaintenanceResult {
pub promotions_count: usize,
pub demotions_count: usize,
pub evictions_count: usize,
pub duration_ms: u64,
pub promotion_decisions: Vec<TierDecision>,
pub demotion_decisions: Vec<TierDecision>,
}
fn current_time_ms() -> i64 {
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_millis() as i64)
.unwrap_or(0)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::tiered::{AccessTrackerConfig, HotTierConfig, SemanticCacheConfig};
struct MockWarmTier {
results: RwLock<Vec<SearchResult>>,
embeddings: RwLock<std::collections::HashMap<ChunkId, Vec<f32>>>,
version: AtomicU64,
replacement_on_search: RwLock<Option<Vec<SearchResult>>>,
}
impl MockWarmTier {
fn new() -> Self {
Self {
results: RwLock::new(Vec::new()),
embeddings: RwLock::new(std::collections::HashMap::new()),
version: AtomicU64::new(1),
replacement_on_search: RwLock::new(None),
}
}
fn add_chunk(&self, chunk_id: ChunkId, embedding: Vec<f32>, score: f32) {
self.results.write().push(SearchResult {
chunk_id: chunk_id.clone(),
score,
});
self.embeddings.write().insert(chunk_id, embedding);
}
}
impl WarmTierSearch for MockWarmTier {
fn search(&self, _query_embedding: &[f32], k: usize) -> Result<Vec<SearchResult>> {
let results = {
let results = self.results.read();
results.iter().take(k).cloned().collect()
};
if let Some(replacement) = self.replacement_on_search.write().take() {
*self.results.write() = replacement;
self.version.fetch_add(1, Ordering::Relaxed);
}
Ok(results)
}
fn get_embedding(&self, chunk_id: &ChunkId) -> Option<Vec<f32>> {
self.embeddings.read().get(chunk_id).cloned()
}
fn get_version(&self) -> u64 {
self.version.load(Ordering::Relaxed)
}
fn len(&self) -> usize {
self.results.read().len()
}
}
fn make_test_searcher() -> TieredSearcher<MockWarmTier> {
let cache = Arc::new(SemanticCache::new(SemanticCacheConfig::default()));
let hot_tier = Arc::new(RwLock::new(HotTier::new(HotTierConfig::default())));
let access_tracker = Arc::new(RwLock::new(AccessTracker::new(
AccessTrackerConfig::default(),
)));
let warm_tier = Arc::new(MockWarmTier::new());
TieredSearcher::new(
cache,
hot_tier,
access_tracker,
warm_tier,
TieredSearcherConfig::default(),
)
}
#[test]
fn test_config_defaults() {
let config = TieredSearcherConfig::default();
assert!(config.enable_cache);
assert!(config.enable_hot_tier);
assert!((config.promotion_threshold - 0.4).abs() < 0.01);
assert_eq!(config.demotion_queries_threshold, 100);
assert!(config.auto_promote_on_project_match);
assert!(!config.debug_tier_decisions);
}
#[test]
fn test_tiered_searcher_creation() {
let searcher = make_test_searcher();
assert_eq!(searcher.query_count(), 0);
assert!(searcher.config().enable_cache);
}
#[test]
fn test_source_tier_equality() {
assert_eq!(SourceTier::Cache, SourceTier::Cache);
assert_ne!(SourceTier::Cache, SourceTier::Hot);
assert_ne!(SourceTier::Hot, SourceTier::Warm);
}
#[test]
fn test_mock_warm_tier() {
let warm = MockWarmTier::new();
let chunk_id = ChunkId::new();
let embedding = vec![1.0, 0.0, 0.0, 0.0];
warm.add_chunk(chunk_id.clone(), embedding.clone(), 0.95);
assert_eq!(warm.len(), 1);
assert!(warm.get_embedding(&chunk_id).is_some());
let results = warm.search(&embedding, 10).unwrap();
assert_eq!(results.len(), 1);
assert_eq!(results[0].chunk_id, chunk_id);
}
fn make_tenant() -> TenantId {
TenantId::new("test_tenant").unwrap()
}
type TestSearcher = (
TieredSearcher<MockWarmTier>,
Arc<SemanticCache>,
Arc<RwLock<HotTier>>,
Arc<RwLock<AccessTracker>>,
);
fn make_searcher_with_warm(warm: Arc<MockWarmTier>) -> TestSearcher {
let cache = Arc::new(SemanticCache::new(SemanticCacheConfig::default()));
let hot_tier_config = HotTierConfig {
hnsw_config: crate::index::HnswConfig {
dimension: 4,
max_elements: 100,
..Default::default()
},
..Default::default()
};
let hot_tier = Arc::new(RwLock::new(HotTier::new(hot_tier_config)));
let access_tracker_config = AccessTrackerConfig {
min_accesses_for_promotion: 2,
..Default::default()
};
let access_tracker = Arc::new(RwLock::new(AccessTracker::new(access_tracker_config)));
let searcher = TieredSearcher::new(
cache.clone(),
hot_tier.clone(),
access_tracker.clone(),
warm,
TieredSearcherConfig::default(),
);
(searcher, cache, hot_tier, access_tracker)
}
fn normalize(v: &mut [f32]) {
let norm: f32 = v.iter().map(|x| x * x).sum::<f32>().sqrt();
if norm > 0.0 {
for x in v.iter_mut() {
*x /= norm;
}
}
}
#[test]
fn test_warm_tier_fallback() {
let warm = Arc::new(MockWarmTier::new());
let chunk_id = ChunkId::new();
let mut embedding = vec![1.0, 0.0, 0.0, 0.0];
normalize(&mut embedding);
warm.add_chunk(chunk_id.clone(), embedding.clone(), 0.95);
let (searcher, cache, _, _) = make_searcher_with_warm(warm);
let tenant = make_tenant();
let result = searcher.search(&embedding, &tenant, None, 10).unwrap();
assert!(!result.cache_hit);
assert!(!result.hot_tier_hit);
assert_eq!(result.source_tier, SourceTier::Warm);
assert_eq!(result.results.len(), 1);
assert_eq!(result.results[0].chunk_id, chunk_id);
assert_eq!(result.results[0].source_tier, SourceTier::Warm);
let repeated = searcher.search(&embedding, &tenant, None, 10).unwrap();
assert!(repeated.cache_hit);
assert_eq!(repeated.results.len(), 1);
assert_eq!(cache.get_stats().cache_hits, 1);
}
#[test]
fn test_hot_tier_fallback() {
let warm = Arc::new(MockWarmTier::new());
let chunk_id = ChunkId::new();
let mut embedding = vec![1.0, 0.0, 0.0, 0.0];
normalize(&mut embedding);
warm.add_chunk(chunk_id.clone(), embedding.clone(), 0.85);
let (searcher, _, hot_tier, _) = make_searcher_with_warm(warm);
let tenant = make_tenant();
{
let ht = hot_tier.write();
ht.promote(chunk_id.clone(), embedding.clone(), tenant.clone(), 0.9)
.unwrap();
}
let result = searcher.search(&embedding, &tenant, None, 10).unwrap();
assert!(!result.cache_hit);
assert!(result.hot_tier_hit);
assert_eq!(result.source_tier, SourceTier::Hot);
assert!(!result.results.is_empty());
let hot_results: Vec<_> = result
.results
.iter()
.filter(|r| r.source_tier == SourceTier::Hot)
.collect();
assert!(!hot_results.is_empty(), "Should have hot tier results");
}
#[test]
fn test_cache_hit_fast_path() {
let warm = Arc::new(MockWarmTier::new());
let chunk_id = ChunkId::new();
let mut embedding = vec![1.0, 0.0, 0.0, 0.0];
normalize(&mut embedding);
warm.add_chunk(chunk_id.clone(), embedding.clone(), 0.95);
let (searcher, _, _, _) = make_searcher_with_warm(warm);
let tenant = make_tenant();
let result1 = searcher.search(&embedding, &tenant, None, 1).unwrap();
assert!(!result1.cache_hit);
let result2 = searcher.search(&embedding, &tenant, None, 1).unwrap();
assert!(result2.cache_hit);
assert_eq!(result2.source_tier, SourceTier::Cache);
}
#[test]
fn test_cache_respects_increasing_and_decreasing_k() {
let warm = Arc::new(MockWarmTier::new());
let embedding = vec![1.0, 0.0, 0.0, 0.0];
for score in [0.9, 0.8, 0.7] {
warm.add_chunk(ChunkId::new(), embedding.clone(), score);
}
let (searcher, cache, _, _) = make_searcher_with_warm(warm);
let tenant = make_tenant();
let small = searcher.search(&embedding, &tenant, None, 1).unwrap();
assert!(!small.cache_hit);
assert_eq!(small.results.len(), 1);
let large = searcher.search(&embedding, &tenant, None, 3).unwrap();
assert!(!large.cache_hit);
assert_eq!(large.results.len(), 3);
let stats = cache.get_stats();
assert_eq!(stats.cache_hits, 0);
assert_eq!(stats.cache_misses, 1);
let medium = searcher.search(&embedding, &tenant, None, 2).unwrap();
assert!(medium.cache_hit);
assert_eq!(medium.results.len(), 2);
}
#[test]
fn test_cache_publication_uses_version_captured_before_search() {
let warm = Arc::new(MockWarmTier::new());
let old_chunk_id = ChunkId::new();
let new_chunk_id = ChunkId::new();
let embedding = vec![1.0, 0.0, 0.0, 0.0];
warm.add_chunk(old_chunk_id.clone(), embedding.clone(), 0.9);
*warm.replacement_on_search.write() = Some(vec![SearchResult {
chunk_id: new_chunk_id.clone(),
score: 1.0,
}]);
let (searcher, _, _, _) = make_searcher_with_warm(warm.clone());
let tenant = make_tenant();
let first = searcher.search(&embedding, &tenant, None, 1).unwrap();
assert!(!first.cache_hit);
assert_eq!(first.results[0].chunk_id, old_chunk_id);
assert_eq!(warm.get_version(), 2);
let second = searcher.search(&embedding, &tenant, None, 1).unwrap();
assert!(!second.cache_hit);
assert_eq!(second.results[0].chunk_id, new_chunk_id);
}
#[test]
fn test_promotion_on_repeated_access() {
let warm = Arc::new(MockWarmTier::new());
let chunk_id = ChunkId::new();
let mut embedding = vec![1.0, 0.0, 0.0, 0.0];
normalize(&mut embedding);
warm.add_chunk(chunk_id.clone(), embedding.clone(), 0.95);
let cache = Arc::new(SemanticCache::new(SemanticCacheConfig::default()));
let hot_tier_config = HotTierConfig {
hnsw_config: crate::index::HnswConfig {
dimension: 4,
max_elements: 100,
..Default::default()
},
..Default::default()
};
let hot_tier = Arc::new(RwLock::new(HotTier::new(hot_tier_config)));
let access_tracker_config = AccessTrackerConfig {
min_accesses_for_promotion: 2,
..Default::default()
};
let access_tracker = Arc::new(RwLock::new(AccessTracker::new(access_tracker_config)));
let config = TieredSearcherConfig {
promotion_threshold: 0.3, enable_cache: false, ..Default::default()
};
let searcher = TieredSearcher::new(
cache,
hot_tier.clone(),
access_tracker,
warm.clone(),
config,
);
let tenant = make_tenant();
for _ in 0..3 {
let _ = searcher.search(&embedding, &tenant, None, 10).unwrap();
}
let decisions = searcher.check_promotions(&tenant, None);
assert!(
!decisions.is_empty(),
"Should have promotion decisions after repeated access"
);
assert!(hot_tier.read().contains(&chunk_id));
}
#[test]
fn test_demotion_after_inactivity() {
let warm = Arc::new(MockWarmTier::new());
let chunk_id = ChunkId::new();
let mut embedding = vec![1.0, 0.0, 0.0, 0.0];
normalize(&mut embedding);
warm.add_chunk(chunk_id.clone(), embedding.clone(), 0.95);
let cache = Arc::new(SemanticCache::new(SemanticCacheConfig::default()));
let hot_tier_config = HotTierConfig {
hnsw_config: crate::index::HnswConfig {
dimension: 4,
max_elements: 100,
..Default::default()
},
..Default::default()
};
let hot_tier = Arc::new(RwLock::new(HotTier::new(hot_tier_config)));
let access_tracker = Arc::new(RwLock::new(AccessTracker::new(
AccessTrackerConfig::default(),
)));
let config = TieredSearcherConfig {
promotion_threshold: 0.4,
demotion_queries_threshold: 5, enable_cache: false,
..Default::default()
};
let searcher = TieredSearcher::new(
cache,
hot_tier.clone(),
access_tracker,
warm.clone(),
config,
);
let tenant = make_tenant();
{
let ht = hot_tier.write();
ht.promote(chunk_id.clone(), embedding.clone(), tenant.clone(), 0.1)
.unwrap();
}
assert!(hot_tier.read().contains(&chunk_id));
let mut other_embedding = vec![0.0, 1.0, 0.0, 0.0];
normalize(&mut other_embedding);
for _ in 0..6 {
let _ = searcher.search(&other_embedding, &tenant, None, 10);
}
let _decisions = searcher.check_demotions(None);
}
#[test]
fn test_project_based_promotion() {
let warm = Arc::new(MockWarmTier::new());
let chunk_id = ChunkId::new();
let mut embedding = vec![1.0, 0.0, 0.0, 0.0];
normalize(&mut embedding);
warm.add_chunk(chunk_id.clone(), embedding.clone(), 0.95);
let cache = Arc::new(SemanticCache::new(SemanticCacheConfig::default()));
let hot_tier_config = HotTierConfig {
hnsw_config: crate::index::HnswConfig {
dimension: 4,
max_elements: 100,
..Default::default()
},
..Default::default()
};
let hot_tier = Arc::new(RwLock::new(HotTier::new(hot_tier_config)));
let access_tracker_config = AccessTrackerConfig {
min_accesses_for_promotion: 2,
project_weight: 0.3, ..Default::default()
};
let access_tracker = Arc::new(RwLock::new(AccessTracker::new(access_tracker_config)));
let config = TieredSearcherConfig {
promotion_threshold: 0.3,
auto_promote_on_project_match: true,
enable_cache: false,
..Default::default()
};
let searcher = TieredSearcher::new(
cache,
hot_tier.clone(),
access_tracker,
warm.clone(),
config,
);
let tenant = make_tenant();
let project_id = "my_project";
for _ in 0..3 {
let _ = searcher
.search(&embedding, &tenant, Some(project_id), 10)
.unwrap();
}
let decision = searcher.maybe_promote_on_access(&chunk_id, &tenant, Some(project_id));
assert!(
decision.is_some() || hot_tier.read().contains(&chunk_id),
"Should promote chunk with project context"
);
}
#[test]
fn test_debug_tier_decisions() {
let warm = Arc::new(MockWarmTier::new());
let chunk_id = ChunkId::new();
let mut embedding = vec![1.0, 0.0, 0.0, 0.0];
normalize(&mut embedding);
warm.add_chunk(chunk_id.clone(), embedding.clone(), 0.95);
let (searcher, _, _, _) = make_searcher_with_warm(warm);
let tenant = make_tenant();
let result = searcher
.search_with_debug(&embedding, &tenant, None, 10)
.unwrap();
assert!(
!result.tier_decisions.is_empty(),
"Debug search should have tier decisions"
);
for decision in &result.tier_decisions {
assert!(!decision.reason.is_empty());
assert!(decision.score.is_some());
}
}
#[test]
fn test_maintenance_result() {
let warm = Arc::new(MockWarmTier::new());
let (searcher, _, _, _) = make_searcher_with_warm(warm);
let tenant = make_tenant();
let result = searcher.run_maintenance(&tenant);
assert!(result.duration_ms < 1000); }
#[test]
fn test_query_counter_increments() {
let warm = Arc::new(MockWarmTier::new());
let (searcher, _, _, _) = make_searcher_with_warm(warm);
let tenant = make_tenant();
let embedding = vec![1.0, 0.0, 0.0, 0.0];
assert_eq!(searcher.query_count(), 0);
let _ = searcher.search(&embedding, &tenant, None, 10);
assert_eq!(searcher.query_count(), 1);
let _ = searcher.search(&embedding, &tenant, None, 10);
assert_eq!(searcher.query_count(), 2);
}
}