Gradient-Enabled Event Queues

• Gradient-enabled event queues are specialized data structures that enable precise, gradient-based simulation of spiking neural networks by handling spike timing and trainable delays.
• They implement custom Jacobian–vector-product rules to accurately propagate gradients through temporally sparse events and support multiple queue architectures optimized for distinct hardware platforms.
• Selective spike dropping and tunable accuracy–performance trade-offs allow these structures to balance simulation fidelity with computational efficiency across CPUs, GPUs, TPUs, and LPUs.

Gradient-enabled event queue structures are specialized data structures designed for efficient simulation and training of @@@@1@@@@ (SNNs), with explicit support for autodifferentiation and exact gradient propagation through temporally sparse event sequences. These structures address the unique requirements of computational neuroscience and neuromorphic machine learning workloads—namely, the need to capture spike timing dynamics, handle heterogeneous and trainable delays, and enable gradient-based optimization across diverse AI accelerator hardware platforms. Key innovations include the derivation of minimal Jacobian–vector-product (JVP) rules for event propagation and architectural adaptations for memory efficiency and hardware parallelism (Landsmeer et al., 5 Dec 2025).

1. Mathematical Foundations of Gradient Propagation through Event Queues

Gradient-enabled event queues generalize the EventProp framework, providing a principled approach to autodifferentiating spike-time events and delayed delivery in SNNs. For a presynaptic neuron with membrane potential $v^{pre}(t)$ and spike time $t^{spk}$, the spike time’s parameter derivative is given by

$$\frac{d t^{spk}}{d\theta} = - \frac{\partial v^{pre} / \partial \theta}{\dot{v}^{pre}} \Big|_{t = t^{spk}}$$

where $\theta$ is any model parameter, and $\partial v^{pre} / \partial \theta$ is the ODE sensitivity up to threshold crossing. Introduction of a trainable delay $d$ modifies the delivery time as

$$t^{post} = t^{spk} + d, \quad \frac{d t^{post}}{d\theta} = \frac{d t^{spk}}{d\theta} + \frac{d d}{d\theta}$$

At event delivery, the postsynaptic variable (such as synaptic conductance) undergoes a jump, and the gradient update is

$$\frac{\partial x^{+}}{\partial\theta} = \frac{\partial x^{-}}{\partial\theta} - \frac{1}{\tau} \frac{\partial t^{post}}{\partial\theta}$$

This formulation supports arbitrary ODE state jumps, multi-compartment biophysical models, and multiple spike events (Landsmeer et al., 5 Dec 2025).

2. Queue Data Structures and Complexity Profiles

Gradient-enabled event queues can be instantiated as several data structures, each with distinct space/time complexity and suitability for gradient backpropagation:

Queue	Memory	Enqueue/Pop Complexity	Gradient Support
Ring	$\mathcal{O}(D)$	$O(1)/O(1)$	yes (dense indices)
LossyRing(n)	$\mathcal{O}(n)$	$O(1)/O(1)$	yes
FIFO Ring(n)	$\mathcal{O}(n)$	$O(1)/O(1)$	yes
SingleSpike	$\mathcal{O}(1)$	$O(1)/O(1)$	yes
SortedArray(n)	$\mathcal{O}(n)$	$O(n\log n)/O(n)$	yes
BinaryHeap(n)	$\mathcal{O}(n)$	$O(\log n)/O(\log n)$	yes
BGPQ(1)	$\mathcal{O}(n)$	$O(\log n)/O(\log n)$	yes

Each “yes” indicates that the structure implements custom JVP logic for forward and backward autodiff (enqueue and pop operations), maintaining both event times and their derivatives (Landsmeer et al., 5 Dec 2025).

3. Hardware Mapping and Performance Benchmarks

Implementations targeting CPUs, GPUs, TPUs, and LPUs reveal that optimal queue structure choice is hardware contingent:

• CPU (Xeon): Tree-based (BinaryHeap) and small FIFO rings excel due to efficient branching and dynamic masking.
• GPU (NVIDIA H100): Branch-free, coalesced O(1) rings outperform heaps by 2–3× for moderate batch sizes, until memory limits push preference to sparse or lossy structures.
• TPU (v4): Hardware-supported SortedArray via sorting intrinsics is ~5× faster than rings or heaps.
• LPU (Groq): Deterministic dataflow mandates ring or precompiled sorts; heap-based structures perform poorly due to inability to branch.

Empirical latency (μs per timestep per neuron) varies across hardware and queue type:

Queue	CPU	GPU	TPU	LPU
Ring	0.02	23.7	5.6	1.8
FIFO Ring[4]	0.01	26.7	5.6	3.5
SortedArray[4]	0.01	23.7	6.5	–
BinaryHeap[7]	0.01	63.4	8.6	–
BGPQ(1)	0.02	68.8	32.8	–

Scalability varies by memory architecture: Ring buffers are limited by on-chip scratch space, while heaps and SortedArrays exhibit different scaling behavior, with SortedArray on TPU remaining flat for $N\approx10^5$ queues (Landsmeer et al., 5 Dec 2025).

4. Selective Spike Dropping and Accuracy–Performance Trade-offs

Resource-efficient, lossy event queues introduce a tunable trade-off between accuracy and performance via spike dropping:

• LossyRingDelay(n): Bin collisions result in spike summing or overwriting.
• FIFO Ring(n): Enqueue fails silently if buffer is full; excess spikes are dropped.
• SingleSpike (Drop/Hold): Only one spike retained; extras overwritten or ignored.

The drop probability for Poisson input rate $\lambda$, delay $d$, and capacity $n$ is

$$P_{\text{drop}} \approx 1 - \sum_{k=0}^n \frac{(\lambda d)^k e^{-\lambda d}}{k!}$$

For typical brain-scale regimes ($\lambda d \approx 2$), a buffer size $n=4$ yields drop rates below 1%. This selective dropping mechanism allows practitioners to balance memory/compute limits with model fidelity (Landsmeer et al., 5 Dec 2025).

5. Relation to Existing Simulators and Exact Gradient Methods

The event queue framework surpasses prior SNN simulators and autodiff toolkits in generality and efficiency:

• Neuroscience Simulators: Traditional platforms such as NEURON, NEST, and Arbor use ring buffers or heaps but lack autodiff integration.
• ML Libraries (Brian2CUDA, SpikingJelly, BrainPy): Rely on dense surrogate gradients, often unsuited for memory-limited hardware.
• Exact Gradient Methods (EventProp, DelGrad, jaxSNN): Historically restricted to single-spike per neuron and basic LIF models.

Gradient-enabled event queues fully support arbitrary state-jump ODEs, many-spike trains, and biophysical multi-compartment models, and can be integrated into JAX, PyTorch, or TensorFlow via custom JVP/VJP rules (Landsmeer et al., 5 Dec 2025).

6. Practical Recommendations and Future Directions

Selection of the optimal event queue is application- and hardware-dependent:

• CPU-only: Prefer BinaryHeap or small FIFO rings for exact delivery.
• GPU: Choose Ring buffers for moderate batch size inference; switch to FIFO Ring or SortedArray for large-scale training.
• TPU: Leverage SortedArray and hardware sorting for maximal throughput.
• LPU: Deploy ring or pipeline-compiled sorts, as branching is detrimental.
• Delays as Parameters: Implement $\partial d/\partial\theta$ term in autodiff per Eq. 2.
• Low Memory Regimes: Use lossy buffers tuned to application statistics to control drop rate.

A potential avenue is the decoupling of primal and tangent queue data structures (e.g., bit-arrays for forward pass, FIFO for gradients) to optimize memory usage and gradient fidelity (Landsmeer et al., 5 Dec 2025).

---

Gradient-enabled event queues permit temporally sparse, high-fidelity, and hardware-efficient simulation and differentiation for SNNs. Adoption of these structures allows exact gradient-based learning in large-scale spiking networks on AI accelerators, with principled tuning of accuracy–performance trade-offs and direct incorporation into modern autodiff frameworks.