Linus Torvalds (torvalds.delete@this.linux-foundation.org) on March 16, 2021 7:25 pm wrote:

> I admit it, the Transputer was actually all kinds of cool.
> I never got to program one, but it always intrigued me.
>
> But I really think that outside of the mythical world where the
> Transputer took over, microkernels are just crazy talk.

I did get to program the Transputer.

It wasn't that cool, in fact.

It pushed threads and channels and message-passing down into microcode, and
it disguised the distinction between on-chip channel communication and
communication to the adjacent cpu over a link.

So far so good. But that only worked because the on-chip scheduling was really
fast because there wasn't an MMU or any kind of memory protection - *and*
it was a stack architecture with a 3-deep hardware stack, so there weren't a
lot of registers to save and restore on a thread-switch. Making thread-switch
fast - but making everything else appallingly slow compared to a RISC with a
decent number of registers.

A bunch of silicon was used for a smallish region of fast on-chip SRAM.
Not cache, not registers, just a region of main memory that went fast. If
your code and data was in that fast RAM, it went fast, and if was off-chip
in DRAM, it went a lot slower.

The theory was that you'd program it in Occam and tweak it around to get
data and code that needed to be fast living in the on-chip RAM.

The reality ? I worked at Meiko, the first company to build systems around
Transputers. Out in the real world, customers didn't want Occam. So the
way it was actually used was by rather conventional C or Fortran, running
on top of a rather conventional OS (based on Minix) which provided normal
services by communicating using the Transputer links as a network (except
you needed a whole network layer to get anywhere-to-anywhere connectivity
on a sparsely-connected topology, typicaly a 2D grid or torus.

Without memory protection, anybody could blow up the OS kernel any time;
or could blow up the network. Not great.

It got some traction, mostly because the T800 transputer had a pretty kick-ass
FPU for the time (maybe 20 MFLOPS ?), *and* you could pack a lot of them quite
densely using the T800 chip, DRAM, and a single ASIC. I worked on software
for a series of VMEbus boards, going up to 16 transputers on a single VME
board and (IIRC) 4 boards in rack.

But the lesson of building software for transputers was exactly what you're
saying - it totally sucks to treat *every* kind of interaction as a serial
communication. At best, you end up copying data many times unnecessarily.
At worst, you introduce huge latency on operations which need to be fast.

It's a blunder.