Struct CompiledGrammarImpl 

pub struct CompiledGrammarImpl {
    pub prewarm_max_threads: usize,
    pub grammar: Arc<GrammarData>,
    pub tokenizer_info: TokenizerInfo,
    pub mask_cache: Mutex<AHashMap<ParserState, Arc<AdaptiveTokenMask>>>,
    pub tag_slice: Arc<AHashMap<i32, Vec<bool>>>,
    pub rule_cache: Option<RuleLevelCache>,
    pub decomposition: GrammarDecomposition,
}

The inner, shared state of a CompiledGrammar. Port of CompiledGrammar::Impl.

Fields

prewarm_max_threads: usize

Maximum synchronous prewarm workers, inherited from the compiler.

grammar: Arc<GrammarData>

The optimized, FSM-accelerated grammar (shared — the lazy MaskGenerator needs an Arc<GrammarData>).

tokenizer_info: TokenizerInfo

The tokenizer this grammar was compiled against.

mask_cache: Mutex<AHashMap<ParserState, Arc<AdaptiveTokenMask>>>

Lazy per-parser-state adaptive-token-mask cache. Equivalent to the C++ adaptive_token_mask_cache — a plain hash map, populated on demand: empty after compilation, filled by [CompiledGrammar:: get_or_compute_mask] as the matcher reaches each state.

The matcher drives one CompiledGrammar single-threaded per request, so the C++ uses a plain unordered_map with no locking. We cannot drop the lock entirely, however: [super::super:: matcher::BatchGrammarMatcher]’s rayon par_iter_mut fill path runs many matchers that were all cloned from one CompiledGrammar — they share this Arc<CompiledGrammarImpl> and may call get_or_compute_mask concurrently. A single uncontended Mutex lock is far cheaper than DashMap’s shard-hash + shard-select machinery on every per-token lookup, while still keeping CompiledGrammarImpl: Sync.

tag_slice: Arc<AHashMap<i32, Vec<bool>>>

TagDispatch second-slice precomputation, keyed by rule id. Built once at compile time and retained here so on-demand mask computation can feed it to the MaskGenerator. Arc-wrapped so MaskGenerator::new clones a pointer, not the map.

rule_cache: Option<RuleLevelCache>

The cross-grammar RuleLevelCache, shared from the owning super::GrammarCompiler (None when the compiler’s cache is disabled, or for the vocab_size == 0 degenerate path). The lazy mask path consults it on a per-state cache miss before falling back to a full MaskGenerator recomputation — a rule structurally identical to one seen in any previous request reuses its computed masks.

decomposition: GrammarDecomposition

WGRAMMAR static/dynamic decomposition (Tier 3c), computed ONCE at compile time by super::decompose::decompose_static_regions. Classifies every rule as fixed scaffolding (with its literal bytes precomputed) or a dynamic value slot — the compile-time index of the grammar’s static structure. See the module docs of decompose.rs for how this composes with Tiers 2 and 3b.

Implementations

impl CompiledGrammarImpl

pub fn memory_size(&self) -> usize

Approximate heap memory usage in bytes. Port of MemorySize(const CompiledGrammar::Impl&). The mask term sums only the masks computed so far (the lazy cache).

Trait Implementations

impl Debug for CompiledGrammarImpl

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.