Struct CacheManager 

pub struct CacheManager { /* private fields */ }

Multi-level caching system for embeddings and computations

Implementations

impl CacheManager

pub fn new(config: CacheConfig) -> Self

Create a new cache manager

pub async fn start(&mut self) -> Result<()>

Start the cache manager with background tasks

pub async fn stop(&mut self)

Stop the cache manager

pub fn get_embedding(&self, entity: &str) -> Option<Vector>

Get cached embedding

pub fn put_embedding(&self, entity: String, embedding: Vector)

Cache an embedding

pub fn get_computation(&self, key: &ComputationKey) -> Option<ComputationResult>

Get cached computation result

pub fn put_computation( &self, key: ComputationKey, result: ComputationResult, computation_time_us: u64, )

Cache a computation result

pub fn get_similarity_cache(&self, query: &str) -> Option<Vec<(String, f64)>>

Get cached similarity results

pub fn put_similarity_cache(&self, query: String, results: Vec<(String, f64)>)

Cache similarity results

pub async fn warm_cache( &self, model: &dyn EmbeddingModel, entities: Vec<String>, ) -> Result<usize>

Warm up cache with frequently accessed entities

pub async fn precompute_common_operations( &self, model: &dyn EmbeddingModel, common_queries: Vec<(String, String)>, ) -> Result<usize>

Precompute and cache common operations

pub fn get_stats(&self) -> CacheStats

Get cache statistics

pub fn clear_all(&self)

Clear all caches

pub fn estimate_memory_usage(&self) -> usize

Get memory usage estimation

pub fn cache_attention_weights( &self, layer_id: &str, input_hash: &str, model_id: Uuid, attention_weights: Vec<f64>, computation_time_us: u64, )

Cache attention weights for a specific layer and input

pub fn get_attention_weights( &self, layer_id: &str, input_hash: &str, model_id: Uuid, ) -> Option<Vec<f64>>

Get cached attention weights

pub fn cache_intermediate_activations( &self, layer_id: &str, input_hash: &str, model_id: Uuid, activations: Vec<f64>, computation_time_us: u64, )

Cache intermediate activations for a specific layer and input

pub fn get_intermediate_activations( &self, layer_id: &str, input_hash: &str, model_id: Uuid, ) -> Option<Vec<f64>>

Get cached intermediate activations

pub fn cache_gradients( &self, layer_id: &str, batch_hash: &str, model_id: Uuid, gradients: Vec<Vec<f64>>, computation_time_us: u64, )

Cache gradients for training optimization

pub fn get_gradients( &self, layer_id: &str, batch_hash: &str, model_id: Uuid, ) -> Option<Vec<Vec<f64>>>

Get cached gradients

pub fn cache_model_weights( &self, model_name: &str, checkpoint: &str, model_id: Uuid, weights: Vec<Vec<f64>>, computation_time_us: u64, )

Cache model weights for quick model switching

pub fn get_model_weights( &self, model_name: &str, checkpoint: &str, model_id: Uuid, ) -> Option<Vec<Vec<f64>>>

Get cached model weights

pub fn cache_feature_vectors( &self, task_name: &str, input_hash: &str, model_id: Uuid, features: Vec<f64>, computation_time_us: u64, )

Cache feature vectors for downstream tasks

pub fn get_feature_vectors( &self, task_name: &str, input_hash: &str, model_id: Uuid, ) -> Option<Vec<f64>>

Get cached feature vectors

pub fn cache_embedding_matrices( &self, operation: &str, batch_hash: &str, model_id: Uuid, matrices: Vec<Vec<f64>>, computation_time_us: u64, )

Cache embedding matrices for batch operations

pub fn get_embedding_matrices( &self, operation: &str, batch_hash: &str, model_id: Uuid, ) -> Option<Vec<Vec<f64>>>

Get cached embedding matrices

pub fn cache_loss_values( &self, loss_type: &str, epoch_batch: &str, model_id: Uuid, losses: Vec<f64>, computation_time_us: u64, )

Cache loss values for training monitoring

pub fn get_loss_values( &self, loss_type: &str, epoch_batch: &str, model_id: Uuid, ) -> Option<Vec<f64>>

Get cached loss values

pub fn cache_generic_result( &self, operation: &str, input_hash: &str, model_id: Uuid, result: Vec<f64>, computation_time_us: u64, )

Cache generic computation results for extensibility

pub fn get_generic_result( &self, operation: &str, input_hash: &str, model_id: Uuid, ) -> Option<Vec<f64>>

Get cached generic result

pub fn clear_computation_cache(&self, operation_prefix: &str) -> usize

Clear cache for specific computation type

pub fn get_cache_hit_rates(&self) -> HashMap<String, f64>

Get cache hit rates by computation type

pub fn adaptive_resize(&mut self)

Adaptive cache resizing based on usage patterns

pub fn batch_cache_computations( &self, computations: Vec<(ComputationKey, ComputationResult)>, )

Batch cache multiple computation results efficiently

pub fn get_computation_type_stats(&self) -> HashMap<String, (u64, u64)>

Get cache efficiency metrics for different computation types