Primitive Reuse Index Overview

• Primitive Reuse Index is a metric that quantifies the reuse of computational primitives like indices, variable slots, and search keys to enhance memory and performance.
• Methodologies such as cross-layer overlap, lifetime-aware allocation, and minimal chain covers enable precise index reuse in sparse attention, algorithmic differentiation, and database queries.
• Implementation strategies including greedy loss-guided selection, reference counting, and bipartite matching offer practical approaches to balance speed, memory use, and optimization trade-offs.

The Primitive Reuse Index is a core concept spanning several high-performance computing domains—including sparse attention in LLMs, algorithmic differentiation, and database query processing. Its unifying theme is the formalization and practical exploitation of redundancy (i.e., "reuse") among collections of indices or primitive computational operations. The Primitive Reuse Index, often instantiated as a metric or a construction, quantifies and enables reuse of computational primitives (indices, selections, or adjoint-variable slots), leading to substantial memory, speed, and scalability enhancements.

1. Formal Definitions and Scope of Primitive Reuse Index

The Primitive Reuse Index refers to constructs and metrics that measure or enable the extent to which computational primitives—such as indices in attention layers, variable slots in algorithmic differentiation, or lexicographic indexes in database systems—can be reused safely and efficiently without recomputation.

• Sparse Attention (LLMs): For an attention layer in a DeepSeek Sparse-Attention (DSA) transformer, given the top-$k$ indices $T^{(\ell)}(t)$ selected per position $t$ in layer $\ell$, the "primitive reuse index" is defined via an overlap metric:

$$\text{overlap}(i,j) = \frac{1}{k} \,\Big\lvert \!\!\bigcap_{t} \left[ T^{(i)}(t) \cap T^{(j)}(t) \right] \Big\rvert$$

averaged across sample queries and positions. This quantifies the cross-layer redundancy in selected tokens (Bai et al., 12 Mar 2026).

• Algorithmic Differentiation (AD): In operator-overloading reverse-mode AD tools, a reuse-index management scheme recycles integer variable indices based on the lifetime of active variables:

$$\mathrm{INDEX}(v) = \text{newIndex()} \;\; \text{on creation}, \;\text{returned on destruction}$$

thus bounding the number of simultaneously active adjoint vector slots to the live variables, not total operations (Sagebaum et al., 2020).

• Databases (Datalog, ISP): A primitive search on a relation $R$ is a conjunctive predicate; the central problem is to select a minimal set of lexicographic indexes such that every primitive search is "covered," exploiting index reuse across queries via minimal chain covers in the subset poset of attribute sets (Jordan et al., 2017).

2. Methodologies for Measuring and Exploiting Index Reuse

Approaches to primitive reuse are characterized by their measurement metrics and practical exploitation strategies:

• Cross-Layer Overlap (Sparse Attention): The overlap matrix $\text{overlap}(i,j)$ is empirically measured (e.g., over 768 sequences of length 200,000 tokens in DSA), revealing blocks of consecutive layers with near-complete index agreement (overlap $0.7$–$1.0$ adjacent layers), motivating indexer anchoring and reuse (Bai et al., 12 Mar 2026).
• Lifetime-aware Index Allocation (Algorithmic Differentiation): Reuse index management schemes track when variable slots become free, recycling them for new variables. Advanced multi-use index managers maintain reference counts to enable reuse while also supporting copy optimization, preventing premature reclamation (Sagebaum et al., 2020).
• Partial Order Chain Covers (Databases): Primitive search patterns are organized into a subset partial order. Using Dilworth's theorem and bipartite matching algorithms, one computes a minimum chain cover; each chain corresponds to a single index that supports all primitive searches in that chain, optimizing index reuse (Jordan et al., 2017).

3. Algorithmic and Implementation Strategies

Practical exploitation of the Primitive Reuse Index involves specific algorithms:

• Greedy, Loss-Guided Selection (Sparse Attention): IndexCache maintains a binary pattern per layer (Full/Shared). Starting from all-Full, layers are greedily switched to index reuse (Shared), with each candidate evaluated for minimal increase in language modeling (LM) loss on a held-out calibration set. This provides a principled, end-to-end loss-minimizing reduction in indexer invocations (Bai et al., 12 Mar 2026).
• Reference Counting and Pooling (Algorithmic Differentiation): The multi-use index manager maintains:
  • freeIndices[]: stack of unused indices
  • useCount[i]: reference count for live copies of each index
  • Assignment, copy, and freeing operations update these to guarantee safe reuse, preserving correctness and memory advantages (Sagebaum et al., 2020).
• Polynomial-Time Minimal Index Selection (Databases): The Minimal Order Selection Problem (MOSP) is solved by constructing a bipartite graph representing the subset order of primitive search attribute sets, computing a maximum matching, extracting a minimum chain cover, and synthesizing a minimal set of indexes. Complexity is $T^{(\ell)}(t)$0, polynomial in the number of searches and attributes (Jordan et al., 2017).

4. Empirical Patterns and Trade-offs in Primitive Reuse

Observational and experimental results provide insight into the practical impact and limits of primitive reuse:

• Sparse Attention Reuse Patterns: In DSA models (47 layers, $T^{(\ell)}(t)$1), up to $T^{(\ell)}(t)$2 of $T^{(\ell)}(t)$3 indexer invocations may be eliminated with negligible accuracy degradation. For example, with $T^{(\ell)}(t)$4 retention (retain $T^{(\ell)}(t)$5 of indexers), there is only a $T^{(\ell)}(t)$6 LM loss and $T^{(\ell)}(t)$7 long-context evaluation degradation; prefill speedup is $T^{(\ell)}(t)$8, decode speedup is $T^{(\ell)}(t)$9 (Bai et al., 12 Mar 2026).
• Memory and Runtime (AD Managers): In the SU2 Onera‐M6 use case, the multi-use index manager reduces total tape memory from $t$0, a $t$1 cut, and achieves faster Jacobian record and reverse times relative to both linear and reuse-only schemes (Sagebaum et al., 2020).
• Index Reuse Efficiency (Databases): The Soufflé Datalog engine, using the chain-cover algorithm, achieves $t$2–$t$3 run time speedup and $t$4–$t$5 memory reduction versus naïve per-search indexing, even for relations with billions of tuples and hundreds of attributes. Even with massive query workloads, index optimization time is orders of magnitude smaller than evaluation time (Jordan et al., 2017).

Domain	Metric/Method	Practical Impact
Sparse Attention	Overlap matrix	Speedup $t$6 (prefill), $t$7 fewer indexers
Differentiation	Slot/reuse counting	$t$8 tape memory, faster reverse pass
Databases	Chain cover poset	$t$9–$\ell$0 memory, $\ell$1–$\ell$2 run time

5. Theoretical Foundations and Complexity

Underlying primitive reuse strategies are several theoretical constructs:

• Commutativity and Coverage (Databases): Because primitive searches are commutative conjunctions, a single index with the correct prefix suffices for multiple queries. The reduction to minimum chain covers exploits this algebraic property via subset partial orders (Jordan et al., 2017).
• Dilworth's and Matching Theorems: The minimum chain cover size equals the size of the maximum antichain in the primitive search poset. Efficient matching algorithms (e.g., Hopcroft–Karp) permit optimal index selection at polynomial cost (Jordan et al., 2017).
• Gradient Linearity (Distillation in Attention): In multi-layer distillation for sparse attention, the KL divergence loss for each Full-layer indexer against the average attention distributions of all served layers exhibits linearity of the gradient, simplifying to a single-target distillation objective (Bai et al., 12 Mar 2026).

6. Limitations, Trade-offs, and Practical Considerations

Primitive reuse schemes are subject to intrinsic limitations and require careful trade-off analysis:

• Attenuating Returns in Reuse (Attention): Beyond a certain reuse threshold (e.g., removing $\ell$3 of indexers), LM loss rises sharply ($\ell$4), degrading long-context scores by over $\ell$5, indicating a hard lower bound set by rapid context or block transitions (Bai et al., 12 Mar 2026).
• Copy Overhead and Reference Management (AD): In copy-light regimes, the multi-use scheme may incur modest (4–9\%) record-time overhead. In copy-rich codes, substantial savings outweigh these costs. Implementation complexity is modest ($\ell$6 array operations per assign/copy/free) (Sagebaum et al., 2020).
• Search/Index Mapping Limitations (Databases): The minimal set of indexes is determined by the structure of query patterns. Although chain cover algorithms are polynomial, index search spaces are exponential; practical feasibility is achieved only through poset reduction (Jordan et al., 2017).

7. Connections, Generalizations, and Impact

The Primitive Reuse Index exemplifies a class of methods unifying memory efficiency, computational acceleration, and formal algorithmic underpinnings across subfields:

• Memory–Runtime Scalability: Exploited in vector-mode AD, large-scale LLMs, and query engines, primitive reuse yields orders-of-magnitude improvements in high-dimensional, high-throughput scenarios.
• Generalization Across Modalities: The underlying reuse formalism applies to indexer invocation (attention), primitive slot management (AD), and index selection (databases), with each expressing reuse via either empirical overlap, lifetime counting, or poset chain coverage.
• Algorithmic Foundations: The intersection of poset theory (Dilworth), greedy/loss-based layer selection, and resource-pooling primitives anchors reuse methodology in both theoretical and empirical grounds.

A plausible implication is that as system scale and context size increase in all domains of application, effective primitive reuse mechanisms become critical not only for hardware and runtime limits, but also for achieving feasible training and inference times. Further work may explore adaptive, dynamic, or learned reuse strategies that optimize these trade-offs online.