WDM Parallelism and Crossbars
A copper wire carries one signal. To carry sixty-four, you need sixty-four wires, sixty-four
drivers, sixty-four times the routing area. An optical waveguide is different in a way that still
feels like cheating: light at 1550.0 nm and light at 1550.8 nm travel down the same
waveguide without speaking to each other, and a
grating can sort them
apart again at the far end. This is wavelength-division multiplexing (WDM) — the
trick that lets a single telecom fibre carry terabits — and for photonic AI hardware it is a
second, independent axis of parallelism. The
MZI-mesh
ONN parallelised over space: N waveguides side by side. WDM parallelises
over colour: N signals in one waveguide, at zero extra area.
This lesson builds the architecture that colour makes possible — the
wavelength-multiplexed crossbar — and meets the humble device that turns out to
be doing half the arithmetic: the photodetector, which sums for free.
The crossbar: rows are colours, columns are dot products
Recall the crossbar from
interconnection
networks: a grid where any row can feed any column through a switch at the crossing.
Replace the switches with tunable transmissions and the crossbar becomes a matrix. Give
input x_j its own wavelength \lambda_j,
encoded as optical power P_j \propto x_j, and send it down row
j. At crossing (j,k) an element set to
transmission w_{jk} taps that fraction of the row's light into column
k. Each column ends in a photodetector.
Now the punchline, which deserves to be stated as the small theorem it is:
- a photodetector with responsivity R outputs current
i = R\,P_{\text{total}} — it responds to total power, not
to fields;
- wavelengths spaced far beyond the detector's bandwidth add in power: their
interference beat notes oscillate at hundreds of gigahertz and average to zero, so
P_{\text{total}} = \sum_j w_{jk} P_j;
- hence the column-k current is
i_k \;=\; R \sum_j w_{jk}\,P_j \;\propto\; (W^{\mathsf T}\mathbf{x})_k
:
the multiply happens at each crossing (power × transmission) and the accumulate
happens in the detector — the sum costs nothing;
- an N \times M crossbar therefore computes an entire matvec in one
symbol time, with M detectors doing all
M(N-1) additions for free.
Contrast this with the mesh. The mesh is coherent: it computes with fields and phases,
can represent signed and complex entries natively, but demands a single laser and interferometric
stability. The crossbar is incoherent: it computes with powers, needs no phase stability
at all — the wavelengths don't even need to come from the same laser — but powers are
non-negative, which has a consequence the "Watch out!" below will not let you skip.
Worked numbers: throughput and the loss budget
Two calculations decide whether a crossbar is practical: how fast it goes, and whether enough
photons survive to the detector. Throughput is easy. With N wavelengths,
M output columns and inputs modulated at r
GHz, the crossbar performs N \times M MACs per symbol:
N = M = 16 at 10 GHz is already
2.56 \times 10^{12} MAC/s from one grid. Loss is where honesty is
required: every component in the light's path — multiplexer, waveguide crossings, the weight
elements themselves — shaves off decibels, and decibels are exponential. Run the budget:
const dB = (fraction: number): number => -10 * Math.log10(fraction);
const fromDb = (loss: number): number => Math.pow(10, -loss / 10);
// A 16-wavelength, 16-output crossbar at 10 GHz:
const N = 16, M = 16, rateHz = 10e9;
console.log("MACs per second: " + (N * M * rateHz).toExponential(2));
// Loss budget for the worst-case light path (all values in dB):
const mux = 2.0; // wavelength multiplexer
const crossings = 15 * 0.2; // 15 waveguide crossings at 0.2 dB each
const weightElement = 1.0; // insertion loss of the tap itself
const demuxToDetector = 1.5;
const total = mux + crossings + weightElement + demuxToDetector;
console.log("total path loss: " + total.toFixed(1) + " dB");
console.log("fraction surviving: " + fromDb(total).toFixed(3));
// Photons per symbol at the detector, from 0.1 mW launched at 1550 nm:
const launched = 1e-4; // W
const photonEnergy = 1.28e-19; // J at 1550 nm
const atDetector = launched * fromDb(total);
const perSymbol = atDetector / rateHz / photonEnergy;
console.log("photons per symbol at detector: " + Math.round(perSymbol));
A few thousand photons per symbol — comfortably detectable, but notice how the budget was spent:
nearly 5 dB, two-thirds of the light, went to plumbing before a single weight was applied. Loss
scales with the path length through the grid, so it grows with N — and
since (as lesson 5 will show) the achievable precision depends on the photon count, loss is not
just wasted power, it is lost bits. Crossbar designs live or die on low-loss crossings
and weight elements; the microring, next lesson, is popular precisely because it does the weighting
job in a ten-micron footprint with modest loss.
Superposition says two co-propagating fields add, and added fields interfere — so why does the
crossbar get away with claiming that wavelengths "add in power"? Because interference between
different frequencies is not stationary: two lasers 100 GHz apart produce a beat note —
the total power sloshes at exactly 100 GHz. A photodetector with 10 GHz of bandwidth simply cannot
follow it; it reports the time average, and the average of the cross term is zero, leaving the sum
of the individual powers. So the "no interference" rule is really a bandwidth statement:
colours don't interfere on a slow detector. The engineering corollary runs both ways.
Space your channels well beyond the detector bandwidth and the crossbar's arithmetic is clean;
cram them too close and the beat notes creep into the signal band as crosstalk. And how many
channels fit is set by the optics: a comb of channels spaced \Delta f
fits \mathrm{FSR}/\Delta f channels into one free spectral range of
whatever resonant device — next lesson, a microring — does the per-wavelength work.
An incoherent crossbar computes with optical power, and power cannot be negative. Taken
literally, that means x_j \ge 0 and
w_{jk} \ge 0: a matrix of purely non-negative entries, which is useless
for real neural networks — half of every trained weight matrix is negative. Every working design
smuggles the sign back in electronically. The standard trick is balanced
photodetection: implement each weight as a pair of transmissions
(w^{+}, w^{-}) feeding two detectors wired in opposition, so the output
current is i \propto \sum_j (w^{+}_{jk} - w^{-}_{jk})\,x_j — signed
weights from unsigned optics, at the price of doubled hardware or halved dynamic range. (Signed
inputs get the same treatment, or a bias offset that is subtracted after detection.) When
you read a crossbar paper, check which trick is in play and what it cost: a "weight" quoted in
the range [-1, 1] always means machinery beyond a single tap. The
coherent mesh, remember, never had this problem — fields carry sign in their phase. Colour buys
parallelism; coherence buys sign. You will keep meeting this trade.
Where this goes next
The crossbar has delegated everything to one unnamed component: the "tunable element set to
transmission w_{jk}". What device applies an analog weight to one
wavelength while ignoring its neighbours, fits by the thousand on a chip, and holds its value
stably? That is a resonant filtering job, and the
next
lesson gives it to the microring resonator — whose sharp resonance makes it both the
perfect wavelength-selective weight and a thermally twitchy device that needs constant
supervision.