acceptodds
Withdrawn from ICLR 2027

ELYSIA: Proving What a Spiking Network Computed — A GPU-native architecture for compound SNN computation

Withdrawn from ICLR 2027, so left out of the paper lists and the map.

Abstract

We present **ELYSIA** (**E**xplicit**ly** Parallel **S**cheduling for **I**nference **A**rchitectures), a GPU-native architecture for compound spiking computation, and its prototype **ELYSIA-P**. An optional certified backend publishes a class only once it has proved that class equals the full computation's, and abstains otherwise. That proof covers the whole temporal computation. It is the only method we tested that releases classes early while returning the full trace's answer exactly: it releases 83.75–86.31% of test classes with no class changed, and no baseline reaches it. It costs 6–15% inside the exact-dyadic conditions and 2.23× per request; outside them an interval enclosure carries the same guarantee. Against our re-implementation of the strongest published early-exit method it costs 10.5–15× more per request and 173–226× batched; that method never exits at this accuracy. A truncated trace changes 150 classes; our calibrated control releases 1.46% early. On a 512-neuron model the enclosure releases all 2,264 classes at median round 11 of 100, none wrong; an exact-hull rule releases all 2,264 at round 12, with the same zero wrong releases, and improves coverage across four models, three passing the fp64 check. A fused LIF kernel runs a whole window in one dispatch, beating `snnTorch` and SpikingJelly by 1.14–1.82× at matched accuracy and 1.201× on the whole compound task. Numerical meaning survives suspension and revision. Over 18 independent streams it retains a median 0.479 [0.432,0.535] of ELYSIA-P's throughput; no dependent stream can use it.

Primary area:
infrastructure, software libraries, hardware, systems, etc.
Keywords:
spiking neural networks, certified computation, GPU systems

Reviews

Among:
Shape:
1234this paper, Bottom 2%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 1.33 over 3 reviews, above 2% of the others.
Reviewer_denDOpenReview ↗
Rating
2
Confidence
4
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper presents ELYSIA, a GPU-native execution framework for compound SNN workloads with task dependencies, suspension/resumption, and input revision. The system combines dependency-aware state management and selective recomputation with a fused LIF kernel, and additionally introduces a certified backend that can prove that an intermediate class prediction matches the full-trace prediction before the temporal computation is fully resolved. The evaluation studies certification coverage and cost, execution correctness under recovery and revision, kernel speed, and end-to-end serving throughput.

Critical strengths
  1. The certified backend is technically interesting: it provides a formal guarantee that an early released class matches the full-trace SNN prediction, rather than relying on a heuristic stopping criterion.
  2. The paper includes fairly extensive correctness validation, including recovery/revision experiments and bitwise agreement checks across execution paths.
Critical weaknesses
  1. I am not convinced that the overall ELYSIA systems problem is sufficiently motivated, novel, or practically important.
    The paper assumes a rather specific workload in which multiple stateful SNN subtasks have dependencies, can be suspended and resumed, and may need selective recomputation after input revision. However, I do not see convincing evidence that this is an important or common SNN inference scenario in practice. The motivation for GPU-native SNN execution itself is also relatively weak, especially without an energy-efficiency argument. At the same time, most of the mechanisms in Section 3—dependency tracking, private task state, checkpoint/resume, artifact/version management, and selective recomputation—look like fairly standard workflow/runtime ideas adapted to SNN temporal state. The empirical results also do not show a strong enough systems benefit to compensate for this limited novelty: under the same kernel, full ELYSIA has substantially lower throughput than the simplified executor, and the revision machinery is not consistently better than simpler memoization-based alternatives. Overall, I find it difficult to justify Section 3 either scientifically or practically. 
  2. The certified early-release component is the most interesting part of the paper, but its practical significance appears much weaker than the framing suggests.
    Certified release guarantees agreement with the full-trace prediction, which is a meaningful property, but it is not the same as conventional early stopping: in some configurations the full trace is still executed, so the system only knows the answer earlier rather than actually avoiding the remaining computation. Moreover, the attractive low-overhead results rely on restrictive exact-dyadic conditions, whereas the general finite-precision certification path can be hundreds of times more expensive. This makes it unclear how much real inference latency, computation, or energy is actually saved. The runtime, fused kernel, and certification components also feel only loosely coupled, making the paper read more like several partially independent contributions than one coherent systems result.
Questions for authors
  1. Can the authors provide a concrete real-world SNN application or deployment in which the proposed compound/revisable execution model is actually needed?
    In particular, I would like to understand how often dependencies, suspension/resumption, and input revision of this form arise in practical inference, rather than in constructed workflow examples. A convincing answer here would materially affect my assessment of the significance of the systems contribution. 
  2. What is the actual end-to-end benefit of certified early release in terms of wall-clock latency, computation, or energy?
    I would especially like this clarified for the general finite-precision setting. Reporting how much work is truly avoided after certification, rather than only when the certificate becomes available, would help determine whether this is practically useful as an inference mechanism. 
  3. How do the authors view the relationship among the runtime, fused kernel, and certified backend as a single contribution?
    Since the paper itself treats the executor and numerical backend as separable, I would like to understand what fundamentally requires these three components to be studied together, rather than as largely independent runtime, kernel, and certification contributions.
Reviewer_YxErOpenReview ↗
Rating
1
Confidence
4
Informativeness
1
Presentation
1
Soundness
1
Read review
Paper summary

This paper presents ELYSIA, a GPU-compatible architecture for spiking neural network (SNN) execution where several SNN subtasks consume each other’s outputs. It also introduces ELYSIA-P, a stripped-down prototype without ELYSIA’s dependency graph, checkpoints, and contracts, which the authors use as a control. The paper makes three main contributions: (1) a certificate that proves an SNN’s predicted class cannot change no matter how the still-unresolved spikes turn out, so it must equal the full-trace prediction, (2) a fused leaky integrate-and-fire (LIF) kernel that runs a whole window of timesteps in one GPU dispatch. It is reported as 1.14 to 1.82$\times$ faster than snnTorch and SpikingJelly at matched accuracy, and (3) an execution architecture for compound, revisable SNN computation. Each subtask keeps its own state, and when an input is revised, only the subtasks that consumed it are recomputed. Experiments are mainly on SHD, with some on N-MNIST.

Critical strengths

(+) Framing SNN early exit as proving the answer is already determined, rather than thresholding confidence, is a interesting angle.

(+) The stated guarantee holds for every input under any data distribution and needs no calibration data.

(+) The problem of sharing a GPU across subtasks loses track of which state belongs to which computation, is real for multi-model SNN pipelines.

(+) The correctness checking is fair. The paper checks bitwise equality between repair and full re-execution, exact-rational audits, and fp64 reference gates.

Critical weaknesses

(-) The certified early release does not save computation, or at least the results contradict this contribution. First, the certified path computes the exact serial trace for the whole batch before running any certification round, which is why Figure 2 places it at 100 of 100 timesteps. Second, as a result, the comparison with SEENN and SpikeCP on changed classes is not apples-to-apples: those methods actually skip timesteps, while the certificate already has the reference answer when it starts. Third, in the deployment sense of deciding before the rest of the input is seen, the shipped rule releases 0 of 2264 samples early. Finally, the certificate is much slower than simply running the network: 362$\times$ the authors’ own fused trace per request and 553$\times$ their fastest no-guarantee version over the whole test split (Table 5).

(-) The theoretical contribution is limited. Theorem 3 is the standard bracketing argument for iterating an order-reversing map. Theorem 4 is interval bound propagation through a linear readout, and Theorem 5 is an affine scan. Furthermore, Theorem 3 does not hold for reset-to-zero neurons (App. I.6 gives a counterexample), yet the 512-neuron result in the abstract uses reset-to-zero and relies on a separate, non-tight enclosure (Prop. 11). The main text does not make this clear. Finally, the authors’ own analysis shows that at the main experimental scales (T = 64 and T = 100), the ideal parallel depth of the release decision exceeds the serial trace depth (App. F.1). Overall, the paper takes a reasonable concept and surrounds it with largely standard theory and measurement, but its own results show that neither the certificate nor the architecture delivers the claimed benefits. This makes the paper inconsistent.

(-) The performance benefits of the systems contributions are not supported by the paper’s own results. (1) ELYSIA retains only 0.48-0.65$\times$ the throughput of its stripped prototype (Sec 5.5, Table 27). (2) The wall-clock benefit of lineage repair is not established (App. E.1). In Table 4, 11 of the 20 restart/repair ratios are below 1, even though the text says nine. Selective repair is also a net loss at revision densities of 1/8 and below (App. H). (3) Packing reduces executed neuron-steps by up to 16$\times$, but throughput changes by at most 13%, and at capacity 4 it moves in the wrong direction (Table 21). (4) A CUDA graph of the step-wise loop is faster than the fused kernel at the paper’s own operating points (0.59$\times$, App. I.5). (5) The 1.14-1.82$\times$ speedup over snnTorch and SpikingJelly is largely Python dispatch overhead (App. I.9).

(-) -) The models are weak. The main results use SHD models at 57.5%, 67.6% and 76.9% accuracy, well below published results of about 95%. The one competitive model, a reproduced DCLS trunk (App. I.4), is limited. The certificate cannot run on its published readout, which is not linear in the spikes, so the authors certify a refit linear head at 92.2%. That result comes from a single seed, 257 of 2,264 samples are never released, and no timing is reported. In addition, the certificate does not cover recurrent candidate-dependent input (Section 4), which excludes the recurrent architectures common among high-accuracy SHD models. It therefore remains unclear how the method performs on competitive models in practice.

(-) The paper is hard to follow and internally inconsistent. The abstract is a list of numbers without context, and the main text cannot be understood without the 50+ page appendix. Appendix F.1 largely repeats Section 5.1. Ratios from different devices, models and timing boundaries (2.23$\times$, 7.8$\times$, 362$\times$, 553$\times$) appear side by side, although the paper states elsewhere that they cannot be combined. Cross-references are broken, e.g., Section 5.1 cites App. I.3 for the DCLS study, which is in I.4.Several sentences are confusing, e.g., under rule the hull rule.

(-) Several references are incorrect, which reduces confidence in the manuscript. For example: (1) “Learning delays in spiking neural networks using dilated convolutions with learnable spacings” (ICLR 2024) is by Hammouamri, Khalfaoui-Hassani and Masquelier, not Wang et al. This matters because App. I.4 is built on this work.

(2) “Dynamic confidence-aware spiking neural network” (Li et al., 2023b) does not appear to exist. The ICCV 2023 paper on dynamic confidence is “Unleashing the Potential of Spiking Neural Networks with Dynamic Confidence” by Chen Li, Edward G. Jones and Steve Furber.

The authors should verify every reference.

Questions for authors
  1. Is there any configuration in which the certified path decides a class without first computing the full exact trace? If so, how does its wall-clock time compare with a plain forward pass?

  2. Table 1 reports the hull rule releasing all 2,264 classes at a median round of 12. Is this in the exact-tail sense (given the reference trace) or the unknown-tail sense (before the rest of the input is seen)? What is its wall-clock cost compared with the 9.4 ms full trace?

  3. How do the certificate, SEENN and SpikeCP compare at equal wall-clock or compute budget, rather than on changed classes alone?

  4. In what deployment setting is a certified class that costs 362–553× the forward pass more useful than simply running the full trace?

Reviewer_pQtTOpenReview ↗
Rating
1
Confidence
2
Informativeness
1
Presentation
1
Soundness
1
Read review
Paper summary

This paper attempts to optimize spiking neural network (SNN) workloads by breaking them into discrete units of work that are scheduled as a DAG, particularly when work can be invalidated (thus invalidating downstream work). They also address early-exit schemes that allow the system to make a classification before fully completing its computation.

Critical strengths

None

Critical weaknesses
  • The manuscript is unpublishable at ICLR (or even arXiv), as written. It lacks a coherent narrative, with no clear definition or motivation of the problem setting in the introduction. It uses undefined terms extensively and limited figures and tables to illustrate their task setting and results.
  • It appears that their method makes use of all computational steps and thus does not even early exit.
  • It's unclear if they are using Triton-backed versions of the baseline libraries, snnTorch and SpikingJelly.
Questions for authors
  • What are the following? window, temporally fused kernel, (admitted) subtasks, neuron groups, score tensor, fusion head, dyadic conditions
  • When would invalidating previous steps in an SNN happen in any practical setting?

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Discussion (0)

Sign in to comment.