Struct FullyPreparedCompressedIndex 

pub struct FullyPreparedCompressedIndex {
    pub layer_idx: usize,
    pub head_idx: usize,
    pub head_dim: usize,
    pub num_tokens: usize,
    pub num_heads: usize,
    pub key_indices_flat: Vec<u32>,
    pub key_norms: Vec<f32>,
    pub block_count: usize,
    pub value_codes: Vec<FibCodeV1>,
    pub scorer: FibScorer,
}

Fully prepared compressed index: pre-unpacks all indices and norms so the scoring loop is just Gram table lookups with no per-call unpacking.

This is the tightest possible hot path for compressed attention scoring.

Fields

layer_idx: usize

Layer index this index was built for.

head_idx: usize

Head index this index was built for.

head_dim: usize

Head dimension.

num_tokens: usize

Number of tokens in the pool.

num_heads: usize

Number of KV heads.

key_indices_flat: Vec<u32>

Pre-unpacked key indices: flat num_entries * block_count u32 buffer, row-major by code_idx = token_idx * num_heads + head_idx. Use key_block(code_idx) to get the slice for one entry.

key_norms: Vec<f32>

Pre-decoded key norms as f32: one per (token, head) entry.

block_count: usize

Number of blocks per vector (= head_dim / k where k is the block dim).

value_codes: Vec<FibCodeV1>

Pre-unpacked value codes (for decode of selected top-k).

scorer: FibScorer

Built FibScorer (for query preparation and Gram table access).

Implementations

impl FullyPreparedCompressedIndex

pub fn key_block(&self, code_idx: usize) -> &[u32]

Get the key indices for one (token, head) entry as a slice.

pub fn prepare_gram_rows(&self, query: &[f32]) -> Result<PrefetchedGramRows>

Prepare a query and pre-fetch the relevant Gram rows.

This copies block_count rows from the Gram table into a contiguous buffer, so the per-token scoring loop becomes sequential gathers from a 2KB working set instead of scattered accesses across 4KB+.

pub fn score_all_tokens( &self, prefetched: &PrefetchedGramRows, ) -> Result<Vec<(usize, f32)>>

Score all tokens against pre-fetched Gram rows.

The hot loop is:

for block in 0..block_count:
    total += gram_rows[block * N + stored_idx]

This is sequential access into a small contiguous buffer — auto-vectorizable and cache-friendly.