The Geometry of Speed on Intel’s Neuromorphic Chip

At Intel’s neuromorphic computing lab, researchers gather around a terminal, not to debug code but to measure how quickly their neuromorphic chip processes information. They’re watching streams of data flow across their screens, tracking the execution speed of a processor that operates nothing like a standard CPU.

For years, neuromorphic computers have attracted interest for their brain-based architecture. These systems process information through networks of artificial neurons connected by synthetic synapses, operating asynchronously rather than following the rigid lockstep of standard CPUs. Yet despite compelling results in specialized applications, adoption has lagged. One key reason is deceptively simple and that is developers cannot reliably predict how fast their algorithms will run. This uncertainty has slowed progress in neuromorphic system design, where researchers often depend on trial and error to gauge performance.

Intel researchers Jonathan Timcheck, Alessandro Pierro, and Sumit Bam Shrestha have now developed the first quantitative runtime prediction model for Loihi 2 that jointly accounts for computation and on-chip communication. The model provides a lower-bound estimate for single-kernel execution on Loihi 2. Their work gives algorithm designers a practical tool to estimate performance before writing a single line of code. Their findings provide a practical reference point for forecasting how neuromorphic workloads perform, from single neurons to large networks.

The Performance Puzzle

Understanding how quickly a program will execute might seem straightforward. On standard CPUs, developers have decades of accumulated wisdom about performance bottlenecks. They know that accessing main memory takes longer than reading from cache, and they can predict how many operations a processor will complete each second.

Neuromorphic systems operate differently. Rather than shuttling data between separate memory and processing units, each core stores its own data and performs calculations right where information resides. When cores need to communicate, they send discrete messages across a network printed directly onto the chip.

This architecture creates new performance dynamics. A calculation might finish quickly if one core has all the data it needs. But if that same workload requires coordination across many cores, communication time can dominate. Because each neuron’s timing depends on message delivery, small delays can ripple through the system. Previous attempts to model neuromorphic performance have focused on counting operations like multiply-accumulate instructions. These metrics capture computational work but miss the communication overhead that often determines actual runtime.

Building a Better Yardstick

The research team took a methodical approach to characterizing Loihi 2’s capabilities. They created a suite of simple benchmark programs, each designed to stress a different aspect of the system. Each benchmark isolates one variable to help disentangle neural computation from message traffic. One benchmark focused purely on computation, having neurons perform dense matrix multiplications that generated enormous numbers of synaptic operations. Another minimized computation while maximizing communication, sending messages between cores to saturate the network bandwidth.

By running these benchmarks and carefully measuring execution time, the team could tease apart the individual factors that contribute to runtime. They measured how long it takes for cores to synchronize between timesteps. They quantified the rate at which a single core can perform different types of operations. Dendrite operations update neuron states, while synaptic operations handle weighted message reception. Most importantly, they characterized how quickly the network can move data between cores.

The authors then synthesized these measurements into a mathematical model. Their approach follows the roofline methodology common in high-performance computing, which provides lower bounds on execution time by identifying the constraining factor for a given workload. Will an operation finish when the slowest core completes its calculations? Or will it wait for messages to traverse a congested network?

Their model expresses runtime as the maximum of five terms: the time to perform dendrite operations (T_dendrite for neuron updates), synaptic operations (T_synapse for weight multiplications), synaptic memory reads (T_read), network communication (T_network), and synchronization overhead (T_sync). By taking the maximum rather than summing these terms, the model captures how Loihi 2’s asynchronous architecture allows different operations to overlap.

Why Prediction Matters

On established processors, performance estimation is part of everyday programming practice. Neuromorphic systems have lacked an equivalent tool. This work fills that gap by translating chip-level behavior into a form that algorithm designers can reason about before deployment.

Testing Reality Against Theory

Having built their mathematical framework, the next step was to see how well it matched actual hardware behavior.

Models are only valuable if they reflect reality. The team measured actual runtime for several workloads on Loihi 2 hardware. Their primary test case was a linear layer, essentially a matrix-vector multiplication spread across multiple cores.

They ran this operation at various scales, from small configurations using just a few cores to large deployments spanning 120 cores. They varied the number of neurons per core and the precision of synaptic weights. Some configurations were bottlenecked by computation, with cores spending most of their time performing arithmetic. Others were constrained by communication, with the network struggling to deliver all the messages between cores.

Across the tested workloads, predicted runtime closely tracked measured execution time, with correlation values ranging from about 0.97 to nearly 1.0 depending on the workload. That level of correlation matches what’s typically seen in established high-performance computing models. The predictions held steady because the model accounts for both message frequency and neuron activity variability.

The team went further by testing a more complex workload: a solver for combinatorial optimization problems. This application alternates between two phases, checking and switching, as it searches for solutions. Both phases generate substantial network traffic as neurons communicate their states to each other.

Even for this more intricate application, the model retained its accuracy across different problem sizes and placement patterns. The authors could predict runtime by accounting for the expected communication load and applying a correction factor for neurons that don’t fire every timestep.

The Loihi 2 runtime model introduces the first quantitative link between neuromorphic algorithm structure and measurable execution time.

The Geography of Speed

Moving from validation to optimization, the model revealed insights about spatial arrangement that can make or break performance.

One valuable finding concerns spatial placement. Because Loihi 2’s cores communicate through on-chip routing channels, neuron placement directly affects message latency and congestion. When mapping a neural network to Loihi 2, developers must decide which neurons live on which cores, and these decisions profoundly shape performance by determining the paths messages travel across the network.

Loihi 2 routes messages using a simple dimension-order scheme: first horizontally, then vertically. This deterministic routing makes traffic patterns predictable but can create bottlenecks when many paths converge on the same network links.

The authors explored this issue by implementing the same neural network with different core placement strategies. A naive rectangular arrangement, packing cores together as densely as possible, created hotspots where traffic from many cores funneled through common links. An X-shaped placement, spreading cores more widely but matching sources and destinations to minimize congestion, ran substantially faster.

By deriving analytical formulas for network congestion under different placement patterns, the team revealed a clear balance between space usage and message traffic. Compact placements use less chip area but create more congestion, leading to superlinear growth in communication time as networks scale. Distributed placements require more physical space but achieve linear scaling with better constant factors.

For a fully dense rectangular placement, the heaviest network link must carry traffic that scales as the 1.5 power of the number of cores. For an X-shaped placement, traffic scales linearly. This difference becomes increasingly consequential as networks grow larger.

Looking Forward

This work provides neuromorphic researchers with a tool they’ve lacked: a way to reason quantitatively about performance before committing to an implementation. Algorithm designers now have a quantitative basis for estimating whether their ideas are constrained by computation or communication. Application engineers can explore different spatial mappings to find arrangements that avoid network bottlenecks. Hardware teams gain a benchmark for evaluating architectural changes against measured performance.

The model focuses specifically on runtime, using Loihi 2’s execution profiling features. Energy consumption, memory utilization, and other aspects of performance remain for future work. The team notes that Loihi 2 includes comprehensive profiling capabilities for these factors, and they plan to extend their model to capture these dimensions. Extending the model to multi-kernel concurrency and energy profiling will affect planning for large-scale simulations where multiple operations run simultaneously.

The current approach applies to single-kernel execution mode, where one operation runs at a time with full network bandwidth access. In pipeline mode, multiple kernels execute concurrently, introducing additional congestion patterns. The model also doesn’t account for all fine-grained timing effects in the hardware, which explains occasional runtime underestimates. These areas present opportunities for refinement.

Still, this work represents a meaningful step toward making neuromorphic systems more accessible. By providing clear performance predictions, it helps bridge the gap between the elegant theory of brain-based computing and the practical realities of writing fast code. As systems expand toward larger neuron counts, predictive models such as this one will remain essential for tuning performance parameters efficiently.

Achieving brain-based computation depends not only on new hardware but also on the software tools and models that help developers understand and optimize it. This study anchors that effort for Intel’s Loihi 2 platform.


Citation: Timcheck, J., Pierro, A., & Shrestha, S. B. (2026). A Compute and Communication Runtime Model for Loihi 2. arXiv preprint arXiv:2601.10035v1.

Related Articles

PHP Code Snippets Powered By : XYZScripts.com
★

Track This Company

Create a free account to add companies to your watchlist and get notified when patents, funding, or key developments change.