Multiflow Computer

~ the last words ~

Josh Fisher was a graduate student thinking about microcode when he wrote down trace scheduling in 1978. The problem he was solving is old and boring to state: a processor with several arithmetic units sitting side by side can only use them if something works out which operations are independent, and a program written as a line of statements does not say. Fisher's answer was to let the compiler guess the likely path through the branches, lay the whole path out flat, schedule it as one enormous block, then patch up the cases where the guess was wrong. Between 1979 and 1981 he turned that into an argument about hardware. If the compiler is doing the work anyway, the chip should stop pretending to reorder anything and just accept one very long instruction word with all the operations already slotted into place.

He started Multiflow in April 1984 near New Haven with John Ruttenberg and John O'Donnell, two people from the Yale group, and closed a first venture round the following January with about twenty employees on the payroll. The product was the Trace, and the naming told you what it was for: a Trace 7/200 issued a 256-bit instruction holding seven 32-bit operations, and the bigger configurations went to 1024 bits and twenty-eight operations at a time. Every slot was picked by the compiler before the machine ever ran.

About 125 of them went out over six years, to universities and labs in the US and in Europe, with a handful reaching Japan. That is a real number for a minisupercomputer startup and it was nowhere near enough. The Traces were built out of standard logic on large boards, which meant Multiflow paid roughly what everyone else on that shelf paid for a cabinet while competing against Convex, against the workstation makers coming up from underneath and eventually against microprocessors that were annoyingly close to good enough. The customers who did buy mostly bought because the compiler turned their unmodified Fortran into something fast, which is a fine reason to buy a machine and a terrible thing to have as your only advantage when you are also a hardware company.

By late 1989 the company was looking for a buyer and Digital Equipment was the serious candidate. The deal did not close. Operations ended on 27 March 1990, five years and eleven months after the founding, with the machines mostly unsellable and the compiler suddenly the most valuable software in the building.

~ the record ~

~ what the compiler had to do ~

The Multiflow compiler is the part that historians keep coming back to. It had to handle several source languages at once and it had to target a family of machines that were not object-code compatible with each other, so the same code base produced working output for a 7-wide box and a 28-wide box without the user thinking about it. It did real optimization at a time when that phrase still meant something contested, and it was reliable, which compilers at research-project maturity generally are not.

After the company closed, that code got licensed out to most of the industry. Intel and Hewlett-Packard both took it, and so did Digital, which had declined to buy the company that made it. Fujitsu, Hughes, HAL and Silicon Graphics followed. A 1993 paper by Lowney and others describing how the thing worked became a standard citation in the field, so the compiler ended up with two afterlives at once: as shipped code inside other companies' toolchains, and as a document that everyone building this kind of compiler afterward had read.

~ the digital deal ~

The usual story for a dead minisupercomputer company is that the cheap microprocessor caught up, and for Multiflow that is the background rather than the cause. The immediate cause was an acquisition that got close enough to plan around and then did not happen. A company burning venture money on ECL boards does not get a second attempt at that in the same quarter.

The timing is the other half. March 1990 is early for this band. Convex had another five years in it and Thinking Machines had another four, and Multiflow went first, before the argument it had started was settled in either direction. The venture money ran out several years ahead of the question it was funding.

~ where the twenty went ~

The original engineering group was around twenty people and it produced four fellows at major American computer companies, two winners of the Eckert-Mauchly Award and several startup founders. Fisher went to HP Labs in 1990 and spent the rest of his career on instruction-level parallelism and embedded VLIW processors, which is roughly where the idea finally landed. That is the part I run into at work. The DSP and vision-accelerator cores inside the edge hardware I write computer vision for issue bundles of operations per instruction and depend on the compiler having picked them in advance, because a drone payload has no transistor budget for a chip that reorders its own work at runtime. The arrangement Multiflow sold 125 of is now shipped by the million, in parts nobody calls a supercomputer, to customers who have never heard the name.

@}-->--

              )
             (_)
            .-'-.
            |   |
            |   |
            |   |
            |   |
          __|   |__   .-.
       .-'  |   |  `-:   :
      :     `---'     :-'
       `-._       _.-'
           '""""""

« previous  ·  random  ·  next »