PART 12 / Advanced

Neuromorphic computing

Which workloads benefit from moving events instead of repeatedly moving dense tensors?

Guided illustrated lesson

What you will learn

Write a hardware-neutral workload specification and compare measured whole-system costs.

Before you begin: Spiking neural networks; Connectome programming

START WITH A QUESTION

Picture this.

Two lamps draw different power, but one stays on much longer. Which uses more energy? Neural hardware comparisons have the same trap: power is a rate, while energy is the accumulated bill for completing the task.

Power
Energy consumed per unit time, measured in watts.
Energy
Accumulated consumption over an interval, measured in joules.
Quantization
Representing values with a limited set of numerical levels.

Read for the idea first. Work through the numbers next. Try answering the questions before opening the explanations.

Computation includes moving information

A processor must store state, fetch values, perform operations and communicate results. Sometimes data movement costs more than the arithmetic you are counting. Neuromorphic designs explore ways to organize computation around neural state and events. Event-driven execution can avoid work when nothing relevant happens, but handling events has its own overhead. A sparse mathematical model may still run in software that updates every neuron on every clock tick.

Imagine routing a crowded mailroom

An event is like a message addressed to several recipients. The system needs a place for each neuron's state, storage for connection values and routes to the targets. Many outgoing targets increase communication work. Finite precision means stored weights may be rounded; partitioning a network may introduce transfers between processing units. These are architectural constraints, not brand-specific details. A design that works well for one activity pattern may behave differently during an event burst.

Power times time gives task energy

A watt is a joule per second. At constant average power P over duration t, E = Pt. The example compares a 2 W system finishing in 0.05 s with a 0.2 W system taking 1 s. Their energies are 0.1 J and 0.2 J. Lower power lost the energy comparison because it ran much longer. If power varies, add the energy from short intervals or integrate the power trace. State whether idle time and startup are included.

Draw the measurement boundary

Place a box around the sensor, host, accelerator, communication and decoder that your claim includes. A chip-only measurement answers a chip-only question. For a robot's battery life, the rest of the system matters too. Compare the same task, quality target and deadline, then sweep workload and activity rate. We make no hardware benchmark claim here; the arithmetic teaches how to recognize a comparison that would actually support one.

SEE THE RELATIONSHIPS

From structure to behavior.

Hardware: a labelled conceptual diagram
Figure 12.1 · Hardware. Original educational diagram; synthetic, not a measured result.
The reasoning pathModel & workload then Placement & routing then Sensor + host + device then Task energy measurement1. Model & workload2. Placement & routing3. Sensor + host + device4. Task energy measurement
A learning flow for this part. Follow the assumptions through to an observable result.

MAKE THE IDEA PRECISE

The mathematics.

E = P t
Symbols and units
SymbolMeaning
EEnergy, joules
PAverage power over the chosen system boundary, watts
tTask duration, seconds

Build the equation, step by step

  1. Power is energy per unit time. Multiply constant power in watts by duration in seconds to obtain energy in joules.
  2. When power varies, integrate it over the task interval or sum sampled power times the sampling interval.
  3. Measure the same completed workload at comparable output quality. Include acquisition, host processing, transfers and decoding when claiming system-level energy improvement.

WORK THROUGH THE NUMBERS

Worked example

A hypothetical 2 W system running for 0.05 s uses 0.1 J. A hypothetical 0.2 W system running for 1 s uses 0.2 J. Lower instantaneous power does not guarantee lower energy per completed task.

A small Python experiment.

Python 3 · Standard library only · Synthetic educational example. Run this in your own notebook or a local file.

systems = [(2.0, 0.05), (0.2, 1.0)]
for power, seconds in systems:
    print(f"{power*seconds:.2f} J")

Read the code as a story

Each tuple contains average watts and elapsed seconds. Multiplying them gives joules, and the loop prints one result per system. The examples deliberately use a slower low-power system so you can see why comparing watts alone is insufficient. No measurements of a commercial chip are hidden in these values.

Expected output

0.10 J
0.20 J

Change one quantity, predict the result, and then run the code again. Explain any difference before adding complexity.

Test your understanding.

Try it: Add a 1 W host that runs for the same duration. Recompute both whole-system budgets.

Self-check: Can a lower-power device consume more energy for a task?

Yes. A device consuming half the power but taking three times as long uses 1.5 times the energy under the constant-power approximation. Idle time, startup and batching also matter; state the measurement boundary.

Where this model stops: No neuromorphic hardware benchmark or deployment is claimed by this book.

A research question: At what activity rate does event-routing overhead erase a sparse model’s advantage?

Record evidence in your mastery worksheet →

PREDICT / TRY / EXPLAIN

Add the forgotten host

Use paper, a calculator or the Python example. Write your prediction before checking the result.

  1. Calculate both original energy budgets.
  2. Add a 1 W host active for each system's entire task duration. Recalculate whole-system energy.
  3. Now compare the systems under a 100 ms deadline. Explain why the energy ranking is not the only acceptance criterion.
Compare with a worked solution

The host contributes 0.05 J to the fast system and 1 J to the slow one. Totals become 0.15 J and 1.2 J. Only the 50 ms system meets the 100 ms deadline in this example. A system that fails the task constraint cannot win simply by quoting an attractive component metric.

CLOSE YOUR NOTES

Can you explain it back?

These questions test the reasoning, not just a remembered phrase. Say your answer out loud or write a sentence first.

01How many joules does 0.5 W consume in 2 s?

Reveal the reasoning for question 1

1 J. Multiplying watts by seconds cancels the per-second part of the unit.

02Does sparse activity prove event-driven execution?

Reveal the reasoning for question 2

No. An implementation might still scan every cell or connection each timestep. Inspect and measure the execution strategy, including host and routing costs.

TAKE THE IDEA WITH YOU

Three things to remember.

  • Power and energy answer different questions.
  • Include data movement and system overhead in the relevant boundary.
  • Compare completed tasks at matched quality and deadlines.

Next we close the loop: a numerical output becomes a command, and the consequence becomes the next observation.

Continue to Part 13 →

THE NEXT LAYER

Chapter depth map.

This introduction provides a first model. The following chapters are outlines for deeper future editions; their full treatments have not yet been published.

Architecture before chip names

12.1 Events, memory and compute · Outline
  1. 12.1.1 CPU/GPU memory traffic and irregular workloads
  2. 12.1.2 Sparse updates and event routing
  3. 12.1.3 Asynchronous and clocked implementations
  4. 12.1.4 Local memory, fan-in and fan-out limits
  5. 12.1.5 Cases where dense accelerators remain competitive
12.2 Platforms and constraints · Outline
  1. 12.2.1 CPU, GPU, FPGA and ASIC design tradeoffs
  2. 12.2.2 Intel Loihi research architecture and access constraints
  3. 12.2.3 Fixed-point arithmetic and parameter quantization
  4. 12.2.4 Placement, routing and communication congestion
  5. 12.2.5 Toolchain portability and hardware availability checks

Measurement and deployment

12.3 Map a model to hardware · Outline
  1. 12.3.1 Separate model semantics from implementation
  2. 12.3.2 Quantize and test spike timing drift
  3. 12.3.3 Memory estimates and partition boundaries
  4. 12.3.4 Input/output conversion overhead
  5. 12.3.5 Fallback behavior when the platform is unavailable
12.4 Benchmark honestly · Outline
  1. 12.4.1 Latency, throughput and idle power
  2. 12.4.2 Energy per task with sensing and host overhead
  3. 12.4.3 Accuracy and batch-size normalization
  4. 12.4.4 Programmability and deployment effort
  5. 12.4.5 Performance extensions: C++, CUDA, Rust and FPGA concepts after profiling the Python baseline
  6. 12.4.6 Evidence required for any efficiency claim

Read with the original sources.

These readings support the concepts and deeper investigation. The worked numbers and illustrations above are teaching examples.

Official hardware research resource

Intel — neuromorphic computing research ↗

Study event processing, memory and mapping constraints. Do not assume public hardware access or transfer platform-specific energy claims to a new task.

Research tutorial / author manuscript

Neftci, Mostafa & Zenke (2019): surrogate gradient learning ↗

A deeper reading after the learning primer in Part 7. Compare the spiking forward rule with the approximate derivative used during training; the book’s scalar gradient example is an original smooth-model exercise.

Complete source register →

Where next?