Struct CompilationCache 

pub struct CompilationCache { /* private fields */ }

Thread-safe compilation cache for storing and retrieving compiled expressions.

Stores compiled EinsumGraph instances keyed by a composite hash that includes the expression structure, compilation configuration, and domain information. This cache is thread-safe and can be shared across compilation threads.

When capacity is exceeded the cache evicts the least-frequently-used entry (lowest hit_count). For strict LRU eviction use LruCompilationCache or CachingCompiler instead.

Example

use tensorlogic_compiler::{CompilationCache, compile_to_einsum_with_context, CompilerContext};
use tensorlogic_ir::{TLExpr, Term};

let cache = CompilationCache::new(100);
let mut ctx = CompilerContext::new();
ctx.add_domain("Person", 100);

let expr = TLExpr::pred("knows", vec![Term::var("x"), Term::var("y")]);

// First compilation: miss (not in cache)
let graph1 = cache.get_or_compile(&expr, &mut ctx, |expr, ctx| {
    compile_to_einsum_with_context(expr, ctx)
}).expect("compile");

// Second compilation: hit (cached)
let graph2 = cache.get_or_compile(&expr, &mut ctx, |expr, ctx| {
    compile_to_einsum_with_context(expr, ctx)
}).expect("compile");

assert_eq!(graph1, graph2);
assert_eq!(cache.stats().hits, 1);

Implementations

impl CompilationCache

pub fn new(max_size: usize) -> Self

Create a new compilation cache with the specified maximum size.

Arguments

• max_size – Maximum number of entries to cache.

Example

use tensorlogic_compiler::CompilationCache;

let cache = CompilationCache::new(100);
assert_eq!(cache.max_size(), 100);

pub fn default_size() -> Self

Create a cache with the default size of 1 000 entries.

pub fn max_size(&self) -> usize

Maximum number of entries the cache can hold.

pub fn get_or_compile<F>( &self, expr: &TLExpr, ctx: &mut CompilerContext, compile_fn: F, ) -> Result<EinsumGraph>

where F: FnOnce(&TLExpr, &mut CompilerContext) -> Result<EinsumGraph>,

Get or compile an expression.

On a cache hit the stored result is returned immediately. On a miss compile_fn is called and the result is stored before returning.

Example

use tensorlogic_compiler::{CompilationCache, compile_to_einsum_with_context, CompilerContext};
use tensorlogic_ir::{TLExpr, Term};

let cache = CompilationCache::new(100);
let mut ctx = CompilerContext::new();
ctx.add_domain("Person", 100);

let expr = TLExpr::pred("knows", vec![Term::var("x"), Term::var("y")]);

let graph = cache.get_or_compile(&expr, &mut ctx, |expr, ctx| {
    compile_to_einsum_with_context(expr, ctx)
}).expect("compile");

pub fn stats(&self) -> CacheStats

Current cache statistics snapshot.

Example

use tensorlogic_compiler::CompilationCache;

let cache = CompilationCache::new(100);
let stats = cache.stats();
assert_eq!(stats.hits, 0);

pub fn clear(&self)

Clear all cached entries.

Example

use tensorlogic_compiler::CompilationCache;

let cache = CompilationCache::new(100);
cache.clear();
assert_eq!(cache.stats().current_entries, 0);

pub fn len(&self) -> usize

Current number of entries in the cache.

pub fn is_empty(&self) -> bool

Returns true when the cache is empty.

Trait Implementations

impl Default for CompilationCache

fn default() -> Self

Returns the “default value” for a type.