Neuromorphic chips run spiking neural networks across a grid of up to a million tiny cores wired by an on-chip network, and deciding which neurons live on which core sets the energy, spike latency, and congestion — but that placement is an NP-hard search over up to N-factorial arrangements, so the meta-heuristics prior tools used (particle swarm, simulated annealing) take over 100 hours or return poor answers once the chip passes a few thousand cores; this work replaces the search with a CONSTRUCTION, threading the neuron clusters onto a Hilbert space-filling curve — a fractal that keeps points close in 1D also close in 2D — so a spiking network's naturally-local neurons land physically near each other almost for free, then polishes with a force-directed step that treats clusters as particles under spring tension, mapping 4 billion neurons in 26 seconds and cutting energy, latency, and congestion by roughly 30 to 90 percent.
The argument in one glance
-
Problem
A million tiny cores, and you must decide which neuron lives on each
A neuromorphic chip (Loihi, TrueNorth, SpiNNaker) runs a spiking neural network by spreading its neurons across a grid of small crossbar cores, each holding only so many neurons and synapses (Loihi, for instance, fits 128 neurons and up to 500K synapses per core), connected by a 2D-mesh Network-on-Chip. To run an SNN you must MAP it: partition the neurons into core-sized clusters, then place each cluster on a physical core. That placement is not cosmetic — when a neuron on one core spikes a neuron on another, the spike travels hops across the mesh, and the number of hops sets the energy spent, the latency added, and the congestion at each router. Place connected neurons far apart and the whole chip crawls and burns power.
-
What people did
Search the arrangement space with meta-heuristics
Placement is a combinatorial optimization, so prior tools treated it as a search. SpiNeMap, PSOPART, DFSynthesizer and others reach for meta-heuristics — particle-swarm optimization, simulated annealing, iterative pair-swapping — usually starting from a random or first-come-first-serve arrangement and improving it step by step. Throw enough search at the space, the thinking goes, and you converge on a low-cost placement.
-
Why it fell short
The search space is N-factorial, and it explodes past a few thousand cores
Two things break. FIRST, the arrangement space is up to N-factorial for N clusters, and searching it from a random start is hopeless at scale — these methods were built for fewer than 5000 cores, and once the chip grows they either fail to finish in any reasonable time (over 100 hours on the largest problems) or return badly inferior placements. SECOND, most prior work spent its effort on the PARTITION of neurons and treated the PLACEMENT of clusters as an afterthought — yet placement is exactly what determines the NoC hop distances that dominate energy, latency, and congestion. Meanwhile hardware kept growing: SpiNNaker2 targets around 10 million cores, and this paper maps networks of up to 4 billion neurons. Random-init meta-heuristic search cannot reach that scale.
-
This paper's idea
Do not search the placement — construct it with a space-filling curve
This work (from Tsinghua) stops searching and starts CONSTRUCTING. It orders the clusters into a 1D sequence so connected clusters sit near each other, then threads that sequence onto the 2D chip along a HILBERT space-filling curve — a fractal whose defining property is that points close together in 1D stay close together in 2D. Because a spiking network is naturally LOCAL (each neuron connects mostly to nearby neurons), locality in the sequence becomes physical locality on the chip, so connected neurons land near each other almost for free, at every scale (the curve is a fractal). A force-directed refinement then polishes the result — treating clusters as particles and their connections as springs, swapping adjacent pairs that lower the total tension energy. The construction is near-linear instead of N-factorial: it maps 4 billion neurons in 26 seconds where prior methods needed over 100 hours, and cuts energy, latency, and congestion by roughly 30 to 90 percent.
Why this problem is worth solving
Neuromorphic hardware only pays off if you can actually load a
network onto it well, and “well” is decided almost entirely by
where each cluster of neurons physically sits. The step that
makes or breaks a run is
the two-stage process of
getting a spiking neural network onto many-core neuromorphic
hardware. First PARTITION: divide the network’s neurons into
clusters small enough to obey a core’s hard limits (so many
neurons, so many synapses per core). Second PLACEMENT: assign
each cluster to a specific physical core in the 2D mesh. The
placement is the consequential half, because cores communicate
by sending spikes as packets across the Network-on-Chip, and a
spike from a cluster on one core to a cluster on another must
hop router by router across the mesh. The number of hops — the
Manhattan distance between the two cores — is directly
proportional to the energy the spike costs, and it adds to spike
latency and to the congestion building up at each router it
crosses. So a placement that scatters connected clusters far
apart makes every spike expensive, slow, and congesting, while
one that keeps connected clusters adjacent makes them cheap,
fast, and quiet
The reason placement is hard is that it is a genuine
combinatorial monster, and the reason it is nonetheless
tractable is a property of the networks themselves. The
arrangement space is up to N-factorial in the number of
clusters, so brute-force search is out, and meta-heuristics that
wander it from a random start stall well before the millions of
cores modern chips offer. But spiking networks are not arbitrary
graphs — they have a
the structural fact that in a
spiking neural network each neuron connects mostly to a small set
of nearby neurons, not to far-flung ones across the whole
network. Connections are local and clustered rather than dense
and global. This is the same locality that biological brains and
convolutional or layered artificial networks exhibit: signal
flows between neighbors and through layers, so the graph of
“who talks to whom” is dominated by short-range edges. That
locality is exploitable — if the physical layout can be made to
respect the network’s own neighbor structure, then most spikes
never have to travel far, because most connections were
short-range to begin with
What people did before, and where it broke
- Partition-focused tools (PACMAN, PyCARL, SpiNeMap). Put most of their effort into how neurons are grouped into clusters and comparatively little into where clusters go. But placement is what sets the NoC hop distances that dominate energy, latency, and congestion, so optimizing partition while neglecting placement leaves the biggest lever unpulled.
- Meta-heuristic placement (PSOPART, particle swarm, simulated annealing). Search the arrangement space by iterative improvement from a random start. Works at small scale but drowns in an N-factorial space as the chip grows — either failing to finish in reasonable time or converging to poor placements past a few thousand cores.
- Dataflow / iterative-swap synthesizers (DFSynthesizer). Begin by randomly allocating clusters and then swap to improve. The random initialization means convergence is slow in an exponentially large space, and the quality depends on how long you can afford to keep swapping.
- Integer linear programming. Can express the placement objective exactly and find optima on small instances, but the solve time explodes with problem size, so it simply does not reach very-large-scale SNNs.
- The gap. No prior method was SCALE-FREE — able to place a network of billions of neurons on a million-core chip in seconds while still respecting the network’s locality to keep spikes short. This paper gets there by replacing search with a locality-preserving construction plus a cheap physical-model refinement.
How the mapping works
Partition, order, thread onto a Hilbert curve, then polish with springs
-
Partition neurons into core-sized clusters
A greedy pass assigns neurons to a cluster one after another until the core's capacity limits are hit (so many neurons, so many synapses per core), then starts a new cluster. This yields the Partitioned Cluster Network — a graph whose nodes are clusters and whose edges are the spike connections between them.
-
Order the clusters into a 1D sequence new
A modified topological sort walks the cluster graph to produce a 1D ordering in which connected clusters end up near each other in the sequence. Cycles (spiking networks are not acyclic) are handled by breaking ties on the smallest cluster index when no zero-in-degree cluster remains. The point is to turn the graph into a line that respects who-connects-to-whom.
-
Thread the sequence onto the chip with a Hilbert curve new
Map the 1D sequence onto the 2D mesh of cores along a Hilbert space-filling curve. Its defining property is LOCALITY PRESERVATION: two positions close in the 1D sequence map to two cores close in 2D. So clusters adjacent in the ordering become physically adjacent on the chip. For non-square meshes a modified Hilbert curve keeps the property on arbitrary rectangles.
-
Why this fits spiking networks so well new
Because SNNs are locally connected (each neuron talks mostly to nearby neurons), locality in the ordering IS locality in the network — and the Hilbert curve turns that into physical closeness on the chip, so most spikes travel only a hop or two. And because the curve is a FRACTAL, this holds at every scale, global and local, giving a good placement everywhere at once rather than only on average.
-
Refine with a force-directed step new
Treat each cluster as a particle and each inter-cluster connection as a spring, with potential energy that grows as connected clusters sit farther apart. Compute the net force (tension) on clusters, queue adjacent position-pairs whose swap would relieve tension, and swap the top fraction (a lambda of about 30 percent) each iteration — always checking the swap still lowers energy, so total energy falls monotonically until no beneficial swap remains.
-
Scale-free by construction new
The Hilbert mapping works at any order of the curve, so there is no size ceiling: the whole pipeline is near-linear rather than the N-factorial search meta-heuristics attempt. It maps 4 billion neurons onto a 1024-by-1024 mesh in 26 seconds, where prior methods needed over 100 hours or failed outright.
The idea
Replace the search with a construction. The prior framing treated placement as an optimization to be searched — throw particle-swarm or annealing at an N-factorial space and iterate. This paper’s move is to stop searching and instead CONSTRUCT a good placement directly, by threading the clusters onto a Hilbert space-filling curve. A construction that is right by design does not need to explore, so it dodges the combinatorial explosion entirely: the pipeline is near-linear and finishes billion-neuron maps in seconds. This is the same leverage the site’s scheduling work keeps finding when it maps a messy problem onto the right mathematical object — the heterogeneous-serving page turns placement into a max-flow it can solve exactly — except here the object is a fractal curve and the “solve” is just walking it. When you can build the answer, you need not hunt for it.
Make the hardware layout speak the network’s own language of locality. The construction works only because two localities line up. Spiking networks are locally connected — neurons talk mostly to neighbors — and the Hilbert curve preserves locality — points close in 1D stay close in 2D. Order the clusters so connected ones are adjacent in the sequence, thread that onto the chip with the curve, and the network’s neighbor structure becomes physical adjacency, so most spikes were always short-range and now travel only a hop or two. This is the exploit-the-structure discipline the site rewards again and again: the same reason the noisy-quantum page can recover an answer from the Hamming-locality of errors, here the locality lives in the connectivity graph, and the win comes from choosing a layout that honors it instead of a generic search that is blind to it. And because the curve is a fractal, the locality is honored at every scale at once.
Start from structure, then polish with a cheap physical model. A Hilbert placement is very good but not optimal, so the paper adds a force-directed refinement borrowed from physics: clusters are particles, connections are springs, and the layout relaxes toward lower tension energy by swapping adjacent clusters whenever that reduces the total. Crucially this polish starts from the already-excellent Hilbert layout, not from random noise, so it has little work to do and converges fast — and each swap is checked to lower energy, so the process is monotone and safe. It is the good-initialization-then-light-refinement pattern the site sees when a system seeds an expensive optimizer with a strong heuristic: the structure does the heavy lifting, and a small, principled local search claims the rest.
Mapping one big spiking network, step by step
From an N-factorial nightmare to a curve you just walk
Placing a large SNN on a 2D-mesh neuromorphic chip. Numbers from the paper's evaluation across 13 benchmarks.
Step 1 of 5
The chip, the network, and the cost of distance
The network has far more neurons than any one core holds, so it is partitioned into thousands or millions of clusters that must be spread across a mesh of cores. Whenever a neuron spikes a neuron on another core, the packet hops across the NoC, and every hop costs energy, adds latency, and congests a router. The entire quality of the run rides on keeping connected clusters physically close.
energy per spike is proportional to the Manhattan (hop) distance between the two cores core limits in the evaluation: 4096 neurons and 64K synapses per core
Why it works
- Spike energy, latency, and congestion all scale with the hop distance between connected cores → so the objective is to keep connected clusters physically close → any layout that turns network adjacency into chip adjacency wins on all three at once.
- Spiking networks are locally connected and the Hilbert curve preserves locality → threading the ordered clusters onto the curve maps 1D-close to 2D-close → connected neurons land on neighboring cores without any search.
- The Hilbert curve is a fractal that maps 1D to 2D at any order → the construction is near-linear and has no size ceiling → 4 billion neurons map in 26 seconds where search needed over 100 hours.
- A constructed placement is strong but imperfect → a force-directed step, starting from that strong layout rather than random noise, relaxes clusters toward lower spring-tension energy → it converges fast and adds another 20 to 30 percent improvement.
- Every force-directed swap is accepted only if it lowers total energy → the refinement is monotone → it can never make the Hilbert layout worse, only better, so the two stages compose safely.
What it costs
- Partition and placement are not co-optimized. Clustering is a simple greedy pass done before placement, with no feedback between them; a partition that groups the wrong neurons together caps how good any placement can be, and this method does not revisit it.
- It assumes a 2D-mesh NoC. The whole locality argument rests on Manhattan distance in a 2D grid. 3D meshes, irregular topologies, or heterogeneous cores are unexplored, and the Hilbert construction would need rework for them.
- Cyclic networks need arbitrary tie-breaking. Spiking networks are not acyclic, so the topological ordering breaks ties by smallest index when no zero-in-degree cluster remains; the effect of this arbitrary choice on final quality is not analyzed.
- Hyperparameters and a hand-chosen energy function. The force-directed step needs the swap fraction (about 30 percent) and a potential-energy function chosen from a few options, with limited sensitivity analysis, so generalization to very different SNN types is not fully established.
- No formal guarantees, and partly synthetic benchmarks. The paper offers no approximation ratio or convergence-quality proof, and while it spans 13 networks, many are synthetic (fully-connected or convolutional patterns) with only a handful of realistic ANN-to-SNN conversions.
The evaluation
Thirteen SNNs from 65 thousand to 4 billion neurons, on meshes from 4-by-4 up to 1024-by-1024 (about a million cores), with per-core limits of 4096 neurons and 64K synapses, against Random mapping, a TrueNorth heuristic, DFSynthesizer, and PSO, measuring energy, average and maximum spike latency, and average and maximum router congestion.
Three ways to place a spiking network on a many-core chip
| Property | Random / simple heuristic | Meta-heuristic search (PSO, DFSynthesizer) | Hilbert curve + force-directed (this work) |
|---|---|---|---|
| How placement is obtained | |||
| Uses the network's locality? | |||
| Scales to millions of cores? | |||
| Runtime at 4 billion neurons | Fast, but placement is poor | ||
| Quality vs best baseline (13-SNN average) | Reference (worst) |
Check yourself
Check your understanding
1. The paper uses a Hilbert space-filling curve for the initial placement instead of searching with a meta-heuristic. Predict why this particular curve, combined with a property of spiking networks, makes the placement nearly free.
2. Prior tools framed placement as a search over arrangements and used particle swarm or simulated annealing; this paper "constructs" the placement instead. Predict why the shift from searching to constructing is what unlocks billion-neuron scale.
3. After the Hilbert placement, the paper adds a force-directed refinement (clusters as particles, connections as springs) rather than accepting the Hilbert layout as-is or running a heavy global optimizer. Predict why refining from the Hilbert layout is the right design.
4. The method's advantage over baselines GROWS with scale — from tens of percent on average to about 94% on the 4-billion-neuron network, and from comparable runtimes to 26 seconds versus over 100 hours. Predict what this widening gap reveals about the approach.
Sources
- ACM DL: Mapping Very Large Scale Spiking Neuron Network to Neuromorphic Hardware — ASPLOS 2023 (full text read via the ACM PDF; no arXiv preprint).